数据类型

string
number
boolean
literal类型
类型的并集
any类型
undefined类型

逻辑控制

if
switch
for
while

枚举

// 类型并集
let b: number | string = 10
//  枚举
enum httpCode {
     OK = 200,
     NOT_FOUND = 404,
     INTERNAL_SERVER_ERROR = 500
 }
 console.log(httpCode.INTERNAL_SERVER_ERROR)
 console.log(httpCode[500])

数组

// 定义数组
const arr:number[] = [1,2,3,4]
const arr:(number|string)[] = [1,2,3,4,'a']
const arr:Array<number> = [1,2,3,4]
// 数组长度
console.log(arr.length)
// 获取数组元素
console.log(arr[1])
// 数组越界：程序不会报错中断，只会打出undefined数据
console.log(arr[10])
// 数组判断是否为空
const a:number[] = []
if (a.leng !== 0) {
  console.log("a is not empty")
}
// 数组尾部增加元素
a.push(2)
// 数组尾部删除元素
a.pop()
// 数组头部插入元素
a.unshift(1)
// 数组头部删除元素
a.shift()
// 数组截取：开始索引和结束索引
a.slice(2,3)
// 删除数组元素：从第二个元素开始，删除3个元素
a.splice(2,3)
// 删除数组元素，并且填充指定的元素：从第二个元素开始，删除3个元素，然后填充两个元素
a.splice(2,3,12,13)
// 数组中查找元素：查找元素3的索引位置
a.indexof(3)
// 数组排序：注意数组排序的bug（按照字母表的顺序排，数字也会出现类似的问题）
a.sort()
// 数组实现元祖：数组越界，则值为undefined
const brr = [1,2,3]
const [a1,a2] = a // 输出：a1 = 1, a2 = 2

对象

• 对象定义

  const emp1 = {
  name: 'a',
  gender: 'male' as 'male' | 'female' | 'other' | 'unknown',
  salary: 8000,
  bonus: undefined as (number | undefined),
  performance: 3.5
  }
  console.log(`${emp1.name}`)

  函数

  函数是一等公民

• 变量的类型可以使函数

• 值（literal）可以使函数
• 对象的字段可以是函数
• 函数的参数可以是函数
• 函数的返回值可以是函数 ```typescript let arr:number[] = [20,2,13,9,1,5]

// 函数的参数是函数，返回值好也是函数，用于包装已有函数实现自己想要的功能 function loggingCompare( comp:(a:number, b:number) => number, log:(a:number,b:number) => void) { return (a:number,b:number) => { log(a,b) return comp(a,b) } }

function compare(a:number,b:number) { return a-b }

function log(a:number,b:number) { console.log(a,b) } arr.sort(loggingCompare(compare, log)) console.log(arr)

```typescript
// 部分应用函数
let s = [1,2,3,4,5,6,7,8,9,10]
function filterArray(arr :number[], f:(a:number) => boolean) {
    return arr.filter(f)
}
function selfFilter(a:number, b:number) {
    return a % b === 0
}
// 单参数函数调用双参数函数
let res = filterArray(s,(v) => selfFilter(v,2))
console.log(res)
// 函数改装
let f = [1,2,3,4,5,6,7,8,9,10]
// 注意该函数参数的依赖关系：理解这种思想
function partApply(f:(a:number,b:number) => boolean, b:number) {
    return (a:number) => {
        return f(a,b)
    }
}
let res2 = filterArray(f, partApply(selfFilter, 2))
console.log(res2)

Promise

function add(a:number, b:number, callback:(v:number) => void):void{
    callback(a+b)
}
add(2,3, v => {
    console.log(v)
})
function addNew(a:number, b:number) :Promise<number> {
    return new Promise((resolve,reject) => {
        if (b %17 ===0) {
            reject(`bad number: ${b}`)
        }
        setTimeout(() => {
            resolve(a+b)
        }, 2000)
    })
}
addNew(2,3).then(res => {
    console.log(res)
    return addNew(res, 17)
}).catch(err => {
    console.log(err)
})
Promise.all([addNew(2,3), addNew(4,5)]).then(res =>{
    const [a,b] = res
    console.log(a,b)
    return addNew(a,b)
}).then(res => {
    console.log(res)
})