类型检查机制 - 《TypeScript》

一、类型推断
二、类型兼容性
三、类型保护

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

一、类型推断

有时候不需要我们直接指定变量的类型（函数返回值类型），TypeScript可以根据某些规则自动的为其推断出一个类型。

基础类型推断 ```typescript // 1、初始化一些变量的时候 let a // ts推断变量a是any类型 let b = 1 // ts推断变量b是nubmer类型 // 2、设置函数默认参数的时候,会根据参数类型，自动推断出返回值类型 let c = (x = 1) => x + 1

// 以上都是从右向做推断，也就是通过右边的类型，推断出左侧变量的类型


- 最佳通用类型推断
- 上下文类型推断
```typescript
// 根据左侧的事件绑定，推断出右侧事件的类型
window.onkeydown = (event: any) => {
    console.log(event)
}
// 可以推断出event中的事件

类型断言（自己可以断言自己代码的类型） ```typescript // 类型断言 // let foo = {} // foo.bar = 1 // 这个代码会报错，foo对象上没有bar属性

// 解决 // 该方案的问题：如果不给foo增加bar属性，也是可以的，这样代码就不严谨了 // interface Foo { // bar: number // } // let foo = {} as Foo // foo.bar = 1

// 优化 interface Foo { bar: number } let foo: Foo = { bar: 1 }

// 类型断言不能随意使用，如果对代码的上下文关系不是非常确定，就不要轻易使用类型断言

```typescript

let name: string|number;
console.log((name! as string).length)
console.log((name! as number).toFixed(2))
// 双重断言
// 不能直接把string|number类型断言成布尔类型，需要双重断言才可以
console.log((name! as any as boolean))

二、类型兼容性

当一个类型Y可以被赋值给另一个类型X时，我们就可以说类型X兼容类型Y。
X兼容Y：X（目标类型）= Y（源类型）
接口之间的兼容性：成员少的兼容成员多的
函数之间的兼容性：参数的个数（参数多的兼容参数少的）；参数类型必须要匹配；返回值类型。
口诀：
结构之间兼容：成员少的兼容成员多的；
函数质检兼容：参数多的兼容参数少的；

三、类型保护

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

enum Type {Strong, week}
class Java {
    helloJava() {
        console.log('hello java')
    }
}
class JavaScript {
    helloJavaScript() {
        console.log('hello javaScript')
    }
}
function getLanguage(type: Type) {
    let lang = type === Type.Strong ? new Java() : new JavaScript()
    // 需要添加类型断言
    if ((lang as Java).helloJava) {
        (lang as Java).helloJava()
    } else {
        (lang as JavaScript).helloJavaScript()
    }
    // 这样写法不好
    return lang
}
getLanguage(Type.Strong)
// 想添加一个功能，创建实例之后，运行实例的打印方法

instanceof（判断一个实例是否属于某个类）

enum Type {Strong, week}
class Java {
  helloJava() {
      console.log('hello java')
  }
}
class JavaScript {
  helloJavaScript() {
      console.log('hello javaScript')
  }
}
function getLanguage(type: Type) {
  let lang = type === Type.Strong ? new Java() : new JavaScript()
  if (lang instanceof Java) {
      lang.helloJava()
  } else {
      lang.helloJavaScript()
  }
  // 这样写法不好
  return lang
}
getLanguage(Type.Strong)

in（判断一个属性是否属于某个对象）

enum Type {Strong, week}
class Java {
  helloJava() {
      console.log('hello java')
  }
  java: any
}
class JavaScript {
  helloJavaScript() {
      console.log('hello javaScript')
  }
  javaScript: any
}
function getLanguage(type: Type) {
  let lang = type === Type.Strong ? new Java() : new JavaScript()
  if ('java' in lang) {
      lang.helloJava()
  } else {
      lang.helloJavaScript()
  }
  // 这样写法不好
  return lang
}
getLanguage(Type.Strong)

typeof（帮助我们判断一个基本类型）

enum Type {Strong, week}
class Java {
  helloJava() {
      console.log('hello java')
  }
}
class JavaScript {
  helloJavaScript() {
      console.log('hello javaScript')
  }
}
function getLanguage(type: Type, x: string | number) {
  let lang = type === Type.Strong ? new Java() : new JavaScript()
  if (typeof x === 'string') {
      // x拥有字符串的方法和属性
      x.length
  } else {
      // x拥有数字的方法和属性
      x.toFixed(1)
  }
  // 这样写法不好
  return lang
}
getLanguage(Type.Strong)

创建类型保护函数

enum Type {Strong, week}
class Java {
  helloJava() {
      console.log('hello java')
  }
}
class JavaScript {
  helloJavaScript() {
      console.log('hello javaScript')
  }
}
function jsJava(lang: Java | JavaScript): lang is Java {
  return (lang as Java).helloJava !== undefined
}
function getLanguage(type: Type, x: string | number) {
  let lang = type === Type.Strong ? new Java() : new JavaScript()
  if (isJava(lang)) {
      lang.helloJava()
  } else {
      lang.helloJavaScript()
  }
  return lang
}
getLanguage(Type.Strong)