类型检查机制

类型检查机制：TypeScript 编译器在做类型检查时，所秉承的一些原则，以及表现出的一些行为。

作用：辅助开发，提高开发效率

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

类型推断

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

基础类型推断

// 推断为 number
let a = 1

// 推断为 any[]
let b = []

// 推断为 c: number
let c = (x = 1) => x + 1

最佳通用类型推断
上下文类型推断

window.onkeydown = (event) => {}

类型断言

interface Foo {
    bar: number
}

let foo = {} as Foo

as const 断言，把类型转换成只读元组

function add() {
    let a = 'mondo'
    let b = (a: number, b: number) => a + b

    return [a, b] as const
}

const [n, m] = add()

m(1, 2)

as 非空断言

const el: HTMLDivElement | null = document.querySelector('.div')

const el: HTMLDivElement = document.querySelector('.div') as HTMLDivElement

const el: HTMLDivElement = document.querySelector('.div')!

接口兼容性

成员少的兼容成员多的

interface X {
    a: any
    b: any
}

interface Y {
    a: any
    b: any
    c: any
}
let x:X = { a: 1, b: 2 }
let y:Y = { a: 1, b: 2, c: 3 }

x = y
// y = x  不能赋值

函数兼容性

type Handler = (a: number, b: number) => void

function hof(handler: Handler) {
    return handler
}

参数个数：多的可以兼容少的
- 可选参数
- 剩余参数
- 固有参数

let handler1 = (a: number) => {}
hof(handler1)

let handler2 = (a: number, b: number, c: number) => {}
// hof(handler2) 报错

参数类型：多的可以兼容少的

let handler3 = (a: string) => {}
// hof(handler3) 报错

函数返回值：少的可以兼容多的

let f = () => ({a: 1})
let g = () => ({a: 1, b: 21})

f = g
// g = f 报错

函数重载：目标函数参数个数多于或者等于源函数参数个数
枚举：数字和枚举可以相互兼容，枚举与枚举间不兼容

enum Fruit { Apple, Banana }
enum Color { Red, Yellow }

let fruit: Fruit.Apple = 3
let no:number = Fruit.Apple
// let color: Color.Red = Fruit.Apple error

类：类的构造函数和静态成员不参与比较，当类中有私有成员时，两个类不兼容，类与子类可以
泛型
- 泛型接口：在两个泛型参数只有类型不相同时，只有在泛型参数使用时才影响
- 泛型函数

类型保护

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

class Java {
    helloJava() {}

    java: any
}

class JavaScript {
    helloJs() {}

    javascript: any
}

function isJava(lang: Java | JavaScript):lang is Java {
    return (lang as Java).helloJava !== undefined
}

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 Java).helloJs()
    // }

    // if (lang instanceof Java) {
    //     lang.helloJava()
    // } else {
    //     lang.helloJs()
    // }

    // if ('java' in lang) {
    //     lang.helloJava()
    // } else {
    //     lang.helloJs()
    // }

    if (isJava(lang)) {
        lang.helloJava()
    } else {
        lang.helloJs()
    }
    return lang
}

使用下面三个类型保护

instanceof
in
typeof
类型保护函数

类型检查机制 ​

类型推断 ​

类型断言 ​

接口兼容性 ​

函数兼容性 ​