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 報錯 不兼容