TypeScript学习笔记

TypeScript学习笔记总结

数据类型

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）可以使函数

• 对象的字段可以是函数

• 函数的参数可以是函数

• 函数的返回值可以是函数

  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)

  // 部分应用函数
  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)
  })