类型检查机制：TypeScript编译器在做类型检查时，所秉承的一些原则，以及表现出的一些行为。
作用：辅助开发，提高开发效率。
类型检查机制通常有：

  • 类型推断
  • 类型兼容性
  • 类型保护

类型推断

不需要指定变量的类型（函数的返回值类型），TypeScript可以根据某些规则自动地为其推断出一个类型。
类型推断通常分为：

  • 基础类型推断
  • 最佳通用类型推断
  • 上下文类型推断
  1. /**
  2.  * 基础类型推断
  3.  */
  4. let a = 1
  5. let b = [1]
  6. // let c = (x = 1) => {}
  7. let d = (x = 1) => x + 1
  8. /**
  9.  * 最佳通用类型推断：从多个类型推断类型，TS会推荐兼容所有类型的类型
  10.  */
  11. // slet e = [1, null]
  13. /**
  14.  * 上下文类型推断：从左往右进行推断，上面是从右往左进行推断
  15.  */
  16. window.onkeydown = (event) => {
  17.     // console.log(event.button)
  18. }
  20. /**
  21.  * 类型断言 as
  22.  * 使用类型断言可以增加代码的灵活性，但是不可滥用，要对上下文有充足的预判，否则会有安全隐患
  23.  */
  24. interface Foo {
  25.     bar: number
  26. }
  27. // let foo = {} as Foo
  28. // foo.bar = 1
  29. let foo: Foo = {
  30.     bar: 1
  31. }

类型兼容性

当一个类型Y可以被赋值给另一个类型X时，我们就可以说类型X兼容类型Y
X兼容Y：X(目标类型) = Y(源类型)
口诀：
结构之间兼容： 成员少的兼容成员多的
函数之间兼容： 参数多的兼容参数少的

  1. /**
  2.  * 基础类型推断
  3.  */
  4. let a = 1
  5. let b = [1]
  6. // let c = (x = 1) => {}
  7. let d = (x = 1) => x + 1
  8. /**
  9.  * 最佳通用类型推断：从多个类型推断类型，TS会推荐兼容所有类型的类型
  10.  */
  11. // slet e = [1, null]
  13. /**
  14.  * 上下文类型推断：从左往右进行推断，上面是从右往左进行推断
  15.  */
  16. // window.onkeydown = (event) => {
  17. //     // console.log(event.button)
  18. // }
  20. /**
  21.  * 类型断言 as
  22.  * 使用类型断言可以增加代码的灵活性，但是不可滥用，要对上下文有充足的预判，否则会有安全隐患
  23.  */
  24. interface Foo {
  25.     bar: number
  26. }
  27. // let foo = {} as Foo
  28. // foo.bar = 1
  29. let foo: Foo = {
  30.     bar: 1
  31. }
  33. /**
  34.  * 类型兼容
  35.  * X兼容Y：X(目标类型) = Y(源类型)
  36.  */
  37. // 关闭strictNullChecks时，字符串类型可以赋值null，这时，我们就可以说字符型兼容null类型
  38. let s: string = 'a'
  39. s = null
  41. // 接口兼容性 
  42. // 成员少的兼容成员多的
  43. interface X {
  44.     a: any;
  45.     b: any;
  46. }
  47. interface Y {
  48.     a: any;
  49.     b: any;
  50.     c: any;
  51. }
  52. let z: X = {a: 1, b: 2}
  53. let y: Y = {a: 1, b: 2, c: 3}
  54. x = y
  55. // y = x
  57. // 函数兼容性
  58. type Handler = (a: number, b: number) => void
  59. function hof(handler: Handler) {
  60.     return handler
  61. }
  62. // 1).参数个数：目标函数的参数个数要多于源函数的参数个数
  63. let handler1 = (a: number) => {}
  64. hof(handler1)
  65. let handler3 = (a: number, b: number, c: number) => {}
  66. // hof(handler3)
  68. // 可选参数和剩余参数
  69. // 关闭strictFunctionTypes，可以兼容
  70. let a1 = (p1: number, p2: number) => {}
  71. let b1 = (p1?: number, p2?: number) => {}
  72. let c1 = (...args: number[]) => {} 
  73. a1 = b1
  74. a1 = c1
  75. b1 = c1
  76. b1 = a1
  77. c1 = a1
  78. c1 = b1
  80. // 2).参数类型
  81. let handler4 = (a: string) => {}
  82. // hof(handler4)
  84. interface Point3D {
  85.     x: number;
  86.     y: number;
  87.     z: number;
  88. }
  89. interface Point2D {
  90.     x: number;
  91.     y: number;
  92. }
  93. let p3d = (point: Point3D) => {};
  94. let p2d = (point: Point2D) => {};
  95. p3d = p2d
  96. // 关闭strictFunctionTypes可兼容以下
  97. p2d = p3d
  99. // 这种函数参数之间相互赋值的情况，叫做函数参数的双向协变
  101. // 3).返回值类型
  102. let h = () => ({name: 'Alice'});
  103. let g = () => ({name: 'Alice', location: 'shanghai'});
  104. h = g
  105. // g = h
  107. function overload1(a: number, b: number): number;
  108. function overload1(a: string, b: string): string;
  109. function overload1(a: any, b: any): any {};
  111. // 枚举兼容性
  112. enum Fruit { Apple, Banana }
  113. enum Color { Red, Green }
  114. let fruit: Fruit.Apple = 3
  115. let no: number = Fruit.Apple
  116. // 枚举之间是完全不兼容的
  117. // let color: Color.Red = Fruit.Apple
  119. // 类兼容性
  120. // 如果类中含有私有成员，则这两种类就不兼容，只有父类和子类相互兼容
  121. class J {
  122.     constructor(p: number, q: number) {}
  123.     id: number = 1
  124.     // private name: string = ''
  125. }
  126. class K {
  127.     static s = 1
  128.     constructor(p: number) {}
  129.     id: number = 2
  130. }
  131. let aa = new J(1,2);
  132. let bb = new K(1);
  133. aa = bb
  134. bb = aa
  135. class L extends J {}
  136. let cc = new L(1, 2)
  137. aa = cc 
  138. cc = aa
  140. // 泛型兼容性
  141. // 泛型接口中没有任何成员是可以相互兼容的
  142. interface Empty<T> {
  143.     value: T
  144. }
  145. // let obj1: Empty<number> = {};
  146. // let obj2: Empty<string> = {};
  147. // obj1 = obj2
  149. // 泛型函数的定义相同，但是没有指定类型参数，他们之间也是项目兼容的
  150. let log3 = <T>(x: T): T => {
  151.     console.log('x')
  152.     return x
  153. }
  154. let log4 = <U>(y: U): U => {
  155.     console.log('y')
  156.     return y
  157. }
  158. log3 = log4

类型保护

TypeScript 能够在特定的区块中保证变量属于某种确定的类型。
可以在此区块中放心地引用此类型的属性，或者调用此类型的方法。

  1. enum Type { Strong, Week }
  3. class Java {
  4.     helloJava() {
  5.         console.log('hello Java')
  6.     }
  7.     java: any
  8. }
  10. class JavaScript {
  11.     helloJavaScript() {
  12.         console.log('hello JavaScript')
  13.     }
  14.     javascript: any
  15. }
  17. function isJava(lang: Java | JavaScript): lang is Java {
  18.     return (lang as Java).helloJava !== undefined
  19. }
  20. function getLanguage(type: Type, x: string | number) {
  21.     let lang = type === Type.Strong ? new Java() : new JavaScript()
  22.     // if ((lang as Java).helloJava) {
  23.     //     (lang as Java).helloJava()
  24.     // } else {
  25.     //     (lang as JavaScript).helloJavaScript()
  26.     // }
  28.     // instanceof
  29.     // if ( lang instanceof Java ) {
  30.     //     lang.helloJava()
  31.     // } else {
  32.     //     lang.helloJavaScript()
  33.     // }
  35.     // in 
  36.     // if ('java' in lang) {
  37.     //     lang.helloJava()
  38.     // } else {
  39.     //     lang.helloJavaScript()
  40.     // }
  42.     // typeof
  43.     // if (typeof x === 'string') {
  44.     //     x.length
  45.     // } else {
  46.     //     x.toFixed(2)
  47.     // }
  49.     // 
  50.     if(isJava(lang)) {
  51.         lang.helloJava()
  52.     } else {
  53.         lang.helloJavaScript()
  54.     }
  55.     return lang
  56. }
  58. getLanguage(Type.Strong)