类型推断和兼容性

WARNING

• 类型推断
  • 基础
  • 多类型联合
  • 上下文类型
• 类型兼容性
  • 基础
  • 函数兼容性
    • 参数个数
    • 参数类型
    • 返回值类型
    • 可选参数和剩余参数
    • 参数双向协变
    • 函数重载
• 枚举
• 类
• 泛型

在有时候可以省略类型的指定，TS会自动推断出对应的类型。

// 会自动推断出是字符串类型
let name = 'xiaoyu'
// let name: string

多类型联合

let arr4 = [1, 'a']
// let arr4: (string | number)[]

上下文类型，根据等号左边推断等号右边的类型

// 此处会推断出 mouseEvent：MouseEvent
window.onmousedown = function (mouseEvent) {
	console.log(mouseEvent, 'mouseEvent')
}

类型兼容性

interface Info3 {
	name: string
}

let infos3: Info3
let info31 = { name: 'xiaoyu' }
let info32 = { age : 18 }
let info33 = { name: '小于', age: 19 }

infos3 = info31
infos3 = info32 // 提示没有name属性
infos3  = info33

函数的兼容性

• 参数个数

let x = (a: number) => 0
let y = (a: number, c: number) => 0

y = x
x = y // 提示错误，右边的必须要小于等于左边的参数才可以

• 参数类型

let x = (a: number) => 0
let y = (b: string) => 0
// x = y // 提示不匹配

• 可选参数和剩余参数

let getSum = (arr: number[], callback:(...args: number[]) => number): number => {
	return callback(...arr)
}

let res = getSum([1, 2, 3], (...args: number[]) : number => args.reduce((a, b) => a + b, 0))
console.log(res, '求和')

// 函数传参一个个的传也是可以的
let res2 = getSum([1, 2, 3], (arg1: number, arg2: number, arg3: number): number => arg1 + arg2 + arg3)

返回值类型

let x1 = () : string | number => 0
let y1 = () : string => 'a'

函数重载

function merge(arg1: number, arg2: number) : number
function merge(arg1: string, arg2: string) : string
function merge(arg1: any, arg2: any) {
	return arg1 + arg2
}

枚举

enum StatusEnum {
	On,
	Off
}

enum AnimalEnum {
	Dog,
	Cat
}
let s = StatusEnum.On
s = AnimalEnum.Dog // 不兼容

类的兼容性，当使用类作为类型来使用的时候其实是检测的是实例

class AnimalClass {
	static age: number
	constructor(name: string) {
	}
}

class PeopleClass {
	static age: string
	constructor(name: string) {
	}
}

class FoodIsClass {
	constructor(name: number) {
	}
}

let animal: AnimalClass
let people: PeopleClass
let food: FoodIsClass

animal = people // 不会检测类的静态成员，只会检测实例的
animal = food // 实例属性不一致

泛型的兼容性

interface Data<T> {}
let data1: Data<number>
let data2: Data<string>
data1 = data2 // 此时赋值是可以的

interface Data<T> {
	data: T
}
let data1: Data<number>
let data2: Data<string>
data1 = data2 // 此时不可以