TypeScript-8.类型推论和兼容性

1.类型推论

• 基础 
• 多类型联合
• 上下文类型

2.类型兼容性

• 基础 
• 函数兼容性   参数个数、参数类型、返回值类型、可选参数和剩余参数、参数双向协变、函数重载
• 枚举 
• 类
• 泛型

  // 类型推论和兼容性
  // 1. 类型推论 基础 多类型联合 上下文类型
  // 2. 类型兼容性 基础 函数兼容性 枚举 类 泛型
  // 函数兼容性 => 参数个数 参数类型 返回值类型 可选参数和剩余参数 参数双向协变 函数重载
  
  // 1.类型推论
  // a.基础
  let vname = 'van' // ts会根据赋值自动判断类型
  // vname = 123 // 报错 上面类型推论为string
  
  // b.多类型联合
  let arr1 = [1, 'a'] // 类型推论 (number|string)[]
  // arr1 = [true, 23, 'aaa', 'bbb'] 报错 不包含boolean
  
  // c.上下文类型
  window.onmousedown = (mouseEvent: any) => {
    console.log(mouseEvent)
  }
  
  // 2. 类型兼容性
  // a.基础（对于对象的检查，是深层次递归检测）
  interface Infos {
    name: string
  }
  let infos: Infos
  const infos1 = { name: 'van' }
  const infos2 = { age: 22 }
  const infos3 = { name: 'dan', age: 13 }
  infos = infos1
  // infos = infos2 报错
  infos = infos3
  
  // b.函数兼容性
  // 参数个数
  let x = (a: number) => 0
  let y = (b: number, c: string) => 0
  y = x
  // x = y 报错  右边参数个数要小于等左边参数个数
  const arrs = [1, 2, 3]
  arrs.forEach((item, index, array) => {
    console.log(item)
  })
  
  // 参数类型
  let x1 = (a: number) => 0
  let y1 = (b: string) => 0
  // x1 = y1 报错
  
  // 可选参数和剩余参数
  const getSum = (arr: number[], callback: (...args: number[]) => number): number => {
    return callback(...arr)
  }
  getSum([1, 7, 3], (...args: number[]): number => args.reduce((a, b) => a + b, 0))  // 灵活一点
  getSum([1, 7, 3], (arg1: number, arg2: number, arg3: number): number => arg1 + arg2 + arg3)
  
  // 函数参数双向协变
  let funcA = (arg: number | string): void => {}
  let funcB = (arg: number): void => {}
  funcB = funcA // ok
  // funcA = funcB 报错
  
  // 返回值类型
  let x2 = (): string | number => 0
  let y2 = () => 'a'
  let z = (): boolean => false
  x2 = y2 // ok
  // y2 = x2 报错
  // y2 = z 报错
  
  // 函数重载
  function merge(arg1: number, arg2: number): number
  function merge(arg1: string, arg2: string): string
  
  function merge(arg1: any, arg2: any) {
    return arg1 + arg2
  }
  merge(1, 3) // 检测返回值为number 没有length属性
  merge('1', '3').length // 检测返回值为string 有length属性
  
  function sum(arg1: number, arg2: number): number
  function sum(arg1: any, arg2: any): any {
    return arg1 + arg2
  }
  let func = merge
  // func = sum 报错 sum缺一种函数重载
  
  // c.枚举的兼容性
  enum StatusEnum{
    On,
    Off
  }
  enum AnimalEnum {
    Dog,
    Cat
  }
  let s = StatusEnum.On
  // s = AnimalEnum.Dog 报错 不兼容
  
  // d.类的兼容性
  class AnimalClass {
    public static age: number
    constructor(public name: string) {}
  }
  class PeopleClass {
    public static age: string
    constructor(public name: string) {}
  }
  class FoodClass {
    constructor(public name: number) {}
  }
  let animal: AnimalClass = { name: 'd'}
  let people: PeopleClass = { name: 'v' }
  let food: FoodClass = { name: 1 }
  people = animal
  // animal = food 报错
  
  class ParentClass {
    private age: number
    constructor() {}
  }
  class ChildrenClass extends ParentClass {
    constructor() {
      super()
    }
  }
  class OtherChass {
    private age: number
    constructor() {}
  }
  
  const children: ParentClass = new ChildrenClass() // 子类可以赋值给父类类型
  // const other: ParentClass = new OtherChass() // 报错 类型有私有属性
  
  // e.泛型兼容性
  interface Data<T> {
    data: T
  }
  let data1: Data<number>
  let data2: Data<string>
  // data1 = data2 报错 不兼容