//index.ts
//数字
let decLiteral: number = 20;
let hexLiteral: number = 0x14;
let binaryLiteral: number = 0b10100
let octalLiteral: number = 0o24
//字符串
let name1: string = 'fd'
let age:number=20
let sentence=`hello my name is ${name1}`//用这种
// let sentence='hello my name is'+name
//数组
let list:number[]=[1,2,3]//推荐第一种
// let list1:Array<number>=[1,2,3]
let x:[string,number]
x=['hello',10]
console.log(x[0].substr(1))
//元组
let y:[string,number]
y=['eee',10]
console.log(y[0].toString())
//enum 枚举类型
enum Color{
Red,
Green,
Blue
}
let c:Color=Color.Green
//any
let notSure:any=4
notSure='maybe a'
notSure=false
//void
function warnUser():void{
console.log('this is warning message')
}
//null undefined
let u: undefined=undefined
let n:null=null //undefined
let num:number|null=3
num=null
//never
function error(msg:string):never{
throw new Error(msg)
}
function fail(){
return error('something failed')
}
//无限循环
function iinj():never{
while (true){
}
}
//object
declare function create(o:object|null):void;
//非原始类型
create({prop:0})
create(null)
//原始类型
create(42)
create('string')
create(false)
create(undefined)
//类型断言
let someValue:any='a string'
//let strLength:number=(<string>someValue).length
let strLength1:number=(someValue as string).length //推荐
变量声明
var 声明
//index.js
//非常典型的闭包场景
// function f(){
// var a=10
// return function g(){
// var b=a+1
// return b
// }
// }
//
// var g=f()
// console.log(g())//11
//var 的作用域规则
// function f(should){
// if(should){
// var x=10
// }
// return x
// }
// f(true)//10
// f(false)//undefined
function sumMatrix(matrix){
var sum=0
for (var i=0;i<matrix.length;i++){
var currentRow=matrix[i]
for (var j = 0; j < currentRow.length; j++) {
sum+=currentRow[j]
}
}
return sum
}
var matrix=[
[1,2,3],
[4,5,6]
]
console.log(sumMatrix(matrix))//21
//面试经常考的
for (let i = 0; i < 10; i++) {
(function (j){
setTimeout(function (){
console.log(j)
},100*j)//0-9
})(i)
// setTimeout(function (){
// console.log(i)
// },100*i)//视频上是 10 个 10, 但是我运行是 0-9
}
let 声明
/* (1)块级作用域
function f(input: boolean) {
let a = 100
if (input) {//块级作用域
let b = a + 1 //a 内部可以访问外部
return b
}
return b //不存在
}
*/
/* (2)
try{
throw 'Oh no'
}catch (e){
console.log('catch')
}
console.log(e)//访问不到
*/
/* (3)在声明之前不能被读写的 ->暂时性死区
a++
let a=1
*/
/* 暂时性死区
function foo(){
return a
}
foo()
let a
*/
//let 变量不能被重复声明 (在块级可以)
/*
function f(condition, x) {
if (condition) {
let x = 100
return x
}
return x
}
f(false, 0)
f(true, 0)
*/
function sumMatrix(matrix: number[][]) {
let sum = 0
for (let i = 0; i < matrix.length; i++) {
let currentRow = matrix[i]
for (let j = 0; j < currentRow.length; j++) {
sum += currentRow[j]
}
}
return sum
}
let matrix=[
[1,2,3],
[4,5,6]
]
console.log(sumMatrix(matrix))//21
//块级作用域的获取
for (let i = 0; i < 10; i++) {
setTimeout(function (){
console.log(i)//10 次 10 setTimeout 是异步执行的
},100*i)
}
解构
//数组解构
let input:[number,number] =[1,2]
function f([first,second]:[number,number]){
console.log(first)//1
console.log(second)//2
}
f(input)
let [first,...rest]=[1,2,3,4]
console.log(first)//1
console.log(rest)//[ 2, 3, 4 ]
let [,second,,fourth]=[1,2,3,4]
console.log(second)//2
console.log(fourth)//4
//对象解构
let o={
a:'foo',
b:12,
c:'bar'
}
let {a,...passthrough}=o
let total=passthrough.b+passthrough.c.length
console.log(total)//15
// let {a,b}:{a:string,b:number}=o
//默认值的情况
function keepWholeObject(wholeObject:{a:string,b?:number}){
let {a,b=1001}=wholeObject
}
//函数声明
type C={a:string,b:number}
function f1({a,b=0}={a:''}):void{
}
f1({a:'yes'})
f()
展开
//数组展开 ...args 浅拷贝
//对象展开
let defaults={
food:'spicy',
price:'$10'
}
let search={...defaults,food: 'rich'}
console.log(search)//{ food: 'rich', price: '$10' }
接口
可选属性+只读属性+额外属性检查
interface LabelledValue{
label:string
}
//类型检测器
function printLabel(labelledObj:LabelledValue){
console.log(labelledObj.label)
}
let myObj={size:10,label:'Size 10 Object'}
printLabel(myObj)//Size 10 Object
//可选属性
interface Square{
color:string
area:number
}
interface SquareConfig{
color?:string
width?:number
//(2)
[propName: string]: any
}
function createSquare(config: SquareConfig):Square{
let newSquare={color:'white',area:100}
if(config.color){
newSquare.color=config.color
}
if(config.width){
newSquare.area=config.width*config.width
}
return newSquare
}
//ts 会对对象字面量, 做额外的属性检查,一旦发现所传的对象有些属性不在定义的属性里面,就会报错
//额外属性检查, 如果 colour 这属性,是真正 bug 的来源, 要去检查 SquareConfig
//(1)一种通过类型断言, 这种并不好
// let squareOptions={colour:'black',width:100} as SquareConfig
//(2)
//let squareOptions = {color: 'black', width: 100}
//let mySquare = createSquare(squareOptions)
let mySquare = createSquare( {color: 'black', width: 100})
//只读属性
interface Point{
readonly x:number
readonly y:number
}
let p1:Point={x:10,y:20}
p1.x=5
let a:number[]=[1,2,3,4]
let ro:ReadonlyArray<number>=a
// ro[0]=12
a=ro as number[]
函数类型+可索引的类型
//函数类型
interface SearchFunc{
(source:string,substring:string):boolean
}
let mySearch:SearchFunc
mySearch=function (src,sub):boolean{
let result=src.search(sub)//result 是 number 类型
return result>-1//变为 boolean 类型
}
//可索引的类型, 数字索引签名
interface StringArray{
[index:number]:string
}
let myArray:StringArray
myArray=['bob','fred']
let myStr:string=myArray[0]
//字符串索引签名
class Animal{
name:string
}
class Dog extends Animal{
breed:string
}
interface NotOkay{
[x:number]:Dog
[x:string]:Animal
}
//
interface NumberDictionary{
[index:string]:number
length:number
// name:string 会报错
}
//只读
interface ReadonlyStringArray{
readonly [index:number]:string
}
let myArray:ReadonlyStringArray=['Alice','Bob']
myArray[2]='Mallory'
import { isPlainObject } from './util'
export function transformRequest(data: any): any {
if (isPlainObject(data)) {
return JSON.stringify(data)
}
return data
}
