[TOC] >[success] # 類型類型推論和兼容 ~~~ 1.'類型推論'：TypeScript里，在有些沒有明確指出類型的地方，類型推論會幫助提供類型 2.'類型兼容'：'TypeScript'的類型系統允許某些在編譯階段無法確認其安全性的操作。當一個類型系統具此屬性時， 被當做是“不可靠”的。我的理解就是'你我本無緣都靠長得像' ~~~ >[info] ## 類型推論 ~~~ 1.TypeScript里，在有些沒有明確指出類型的地方，類型推論會幫助提供類型 ~~~ >[danger] ##### 通用類型 ~~~ 1.ts 會根據賦值做出類型推論 ~~~ ~~~ let name1 = 'wang' // 等同于 let name1:string = 'wang' let arr = [1,'a'] // let arr: (number|string)[] = [1,'a'] arr = [1, 'a', 1] // arr = [1, 'a', true] // 報錯 // 如果定義的時候沒有賦值，不管之后有沒有賦值，都會被推斷成 any 類型而完全不被類型檢查： let myFavoriteNumber; myFavoriteNumber = 'seven'; myFavoriteNumber = 7; ~~~ >[danger] ##### 上下文歸類 * 這里有個小疑問后期調查一下 ~~~ // 正常情況下如果沒有給a賦值類型，a會被自動推斷類型為MouseEvent // 但是現在沒有 需看時候后期需要配置什么 window.onmousedown = (a)=> { console.log(11) } ~~~ * 如果我們不知道我們參數的類型是什么，又不想使用any，可以如圖查看  ~~~ window.onmousedown = (a:MouseEvent)=> { console.log(11) } ~~~ >[info] ## 類型兼容 ~~~ 1.'TypeScript'的類型系統允許某些在編譯階段無法確認其安全性的操作。當一個類型系統具此屬性時， 被當做是“不可靠”的。我的理解就是'你我本無緣都靠長得像' ~~~ >[danger] ##### 基本規則 ~~~ 1.下面有個案例'infos'的類型已經定義好是一個包含'name'字段，我們以把只具有一個'name'字段的屬性'infos1' 賦值給infos是可以的，在吧infos2 這種只要包含'name'字段的對象賦值也是可以的。但是'infos3'這種不具備包含 'name'字段的對象賦值就發現報錯 3.'總結'：'類型兼容性 如果x要兼容y，那么y至少具有與x相同的屬性'，你可以把'多的賦值給少的'，但是不能'把少'的賦值 給'多的' ~~~ ~~~ interface Info{ name:string } let infos:Info const infos1 = { name: 'w' } const infos2 = {name:'w',age:12} const infos3 = { age: 18 } infos = infos1 infos = infos2 //?infos2?=?infos?//?報錯?少的賦值給多的 // infos = infos3 // 報錯的 ~~~ * 注意我們上面案例是 兩種變量相互賦值 ~~~ 1.不是下面這種定義了規定類型，賦值后卻不按照規定類型賦值 2.'注意'：上面是兩個變量相互賦值，下面這個是對定義變量賦值不要搞錯 ~~~ ~~~ interface Info{ name:string } // let infos:info = {name:'w',age:12} // 報錯的 // let infos:info // infos = {name:'w',age:12} // 報錯 ~~~ >[danger] ##### 函數兼容 -- 函數參數 ~~~ 1.參數個數一致，類型不同，是不能相互賦值的 2.參數個數不一致，相同類型參數的位置也不一致，是不可以相互賦值的 3.參數個數不一致，相同類型參數的位置一致，可以相互賦值，但是'只能把少的賦值給多的' ~~~ * 首先參數個數一致，類型不同 ~~~ let xx = (a: number) => 0 let yy = (a: string) => 0 // xx = yy // 報錯參數類型不一致 ~~~ * 參數個數不一致，相同類型參數的位置也不一致 ~~~ let x = (c: number) => 0 let y = (a: string, b: number) => 0 // xx = yy // 報錯 ~~~ * 參數個數不一致，相同類型參數的位置一致，可以相互賦值，但是'只能把少的賦值給多的 ~~~ 1.解釋為什么只能把少的賦值給多的，你把少的賦值給多，多的那個沒被賦值的參數相當于'undefind' 沒有影響， 但是你把多的賦值給少的，少的無緣無故多了一個參數那就報錯了 ~~~ ~~~ let x = (a: number) => 0 let y = (a: number,b:string) => 0 y=x // 把少的 給多的，多的可以只用一個參數另一不用 // x = y // 把多的參數，賦值給少參數，因為x定義只有一個a，你多給他一個b他也用不了 ~~~ >[danger] ##### 函數兼容 -- 剩余參數 ~~~ 1.當一個函數有剩余參數時，它被當做無限個可選參數 ~~~ ~~~ const getSum = (nlist:number[],callback:(...args:number[])=>number)=>{ callback(...nlist) } getSum([1,2,3],(...args:number[])=>{ const sum = args.reduce((a, b) => a + b) console.log(sum) // 6 return sum }) getSum([1, 2, 3], (n1:number,n2:number) => { console.log(n1+n2) return n1+n2 }) ~~~ >[danger] ##### 函數兼容 -- 函數參數雙向協變 ~~~ 1.當A的參數類型不確定，B 的參數類型為A中不確定參數類型中的一個。可以吧多類型賦值給少類型的 ~~~ ~~~ let funcA = (arg1: number | string) => { } let funcB = (arg1: number ) => { } // funcA = funcB // 錯誤的 funcB = funcA ~~~ >[danger] ##### 函數兼容 -- 返回值類型 ~~~ 1.函數返回類型可以把少的賦值給多的，多的不能賦值給少的 ~~~ ~~~ let funcTypeA = (): string | number => 0 let funcTypeB = (): number => 0 funcTypeA = funcTypeB // funcTypeB = funcTypeA // 報錯 ~~~ >[danger] ##### 函數兼容 -- 函數的重載 ~~~ 1.重載類型不一致怎么賦值都是錯 ~~~ ~~~ function merge(n1: number, n2: number): number function merge(n1: string, n2: string): string // 雖然是any 但是只能是 string 或者 number function merge(n1:any,n2:any):any{ return n1+n2 } function sum(n1: number, n2: number): number function sum(n1: any, n2: any): any { return n1 + n2 } // 問題重載類型不一致怎么賦值都是錯 // merge = sum // 報錯 // sum = merge // 報錯 ~~~ >[danger] ##### 枚舉的兼容 ~~~ 1.不同枚舉類型是不兼容的 ~~~ ~~~ enum StatusEnum{ Off, On } enum AnimalEnum{ Dog, Cat } let s = StatusEnum.Off // s = AnimalEnum.Dog // 不同枚舉類型是不兼容的 ~~~ >[danger] ##### 類 ~~~ 1.類有靜態部分和實例部分的類型。 比較兩個類類型的對象時，只有實例的成員會被比較。 靜態成員和構造函數不在比較的范圍內 2.向下面的案例'AnimalClass ' 和'PeopleClass',中 因為static 是靜態類方法所以他們age屬性是不影響他們相互賦值 ，比較的都是實例成員，也因此'FoodIsClass ' 的name屬性類型和另外兩個不一致不能相互賦值 ~~~ ~~~ class AnimalClass { public static age: number constructor(public name: string) {} } class PeopleClass { public static age: string constructor(public name: string) {} } class FoodIsClass { constructor(public name: number) {} } let animal: AnimalClass = new AnimalClass('w') let people: PeopleClass = new PeopleClass('w') let food: FoodIsClass = new FoodIsClass(1) people = animal // animal = food // 報錯 ~~~ * 類的私有成員和受保護成員？ 后續看 >[danger] ##### 泛型 ~~~ 1.如果定義接口里面沒東西，那么泛型類型可以交叉賦值，如果有了東西類型不一致就報錯了 ~~~ ~~~ interface Empty<T> { } let x: Empty<number>; let y: Empty<string>; x = y; interface NotEmpty<T> { data: T; } let x: NotEmpty<number>; let y: NotEmpty<string>; x = y; // Error, because x and y are not compatible ~~~