你需要知道的 TypeScript 高级类型3(小结)

泛型

语法为函数名字后面跟一个<参数名>参数名可以随便写，例如这写了T，当我们使用函数的时候把参数类型传进去就可以了，也就是动态类型。

使用泛型前

// number类型
function num(a: number, b: number): Array<number> {
  return [a, b]
}
num(1, 2)
//string类型
function str(a: string, b: string): Array<string> {
  return [a, b]
}
str('1', '2')

从这里可以看出使用泛型前，如果有多种类型的数据传入，那么这种方式就略显冗余，赶紧润

使用泛型后

//定义时类型不明确传一个变量T
function fun<T>(a: T, b: T): Array<T> {
  return [a, b]
}
//使用时需要明确数据类型
fun<number>(123, 4)//number
//也可以简写，ts会推断出参数是什么类型
fun('123','234')//string

定义多类型泛型

function Sub<T,U>(a:T,b:U):Array<T|U>{
	let arr:Array<T|U>=[a,b]
	return arr
}
Sub<number,boolean>(1,false)
//同样这里也可以简写
Sub(1,false)

兼容多种类型的需求

泛型约束

interface Len{
	length:number
}
//通过继承约束T参数必须有length属性
function getLength<T extends Len>(arg:T){
	return arg.length
}
getLength([1,2,3])//√
getLength(['1','2','3','4','5'])//√
getLength(1)//x

使用keyof约束泛型对象

这里使用到的Ts泛型和泛型约束，首先定义了T类型并使用extends 关键字继承了object类型的子类型，然后使用keyof操作符获取T类型的所有键，他的返回类型是联合类型，最后利用extends关键字约束K类型必须是keyof T联合类型的子类型

keyof obj：返回的是联合类型

function prop<T, K extends keyof T>(obj: T, key: K) {
    return obj[key];
}
let obj = { a: 1, b: 2, c: 3 };
prop(obj, "a");

泛型类

class Sub<T>{
  attr: T[] = []
  add(a: T): T[] {
    return [a]
  }
}
//此处定义泛型为number
let num = new Sub<number>()
num.attr = [1, 2, 3, 4]
num.add(2)
//此处定义泛型为string
let str = new Sub<string>()
str.attr = ['a', 'b', 'c', 'd']
str.add('e')

进阶用法 infer（占位符）

//场景：定义一个类型，如果是数组就返回 数组元素的类型 ，否则传入什么类型就返回什么类型

type TYPE<T>=T extends Array<infer U>?U:T
type A=TYPE<(string|number)[]>//string|number
type B =TYPE<boolean>//boolean



type TYPE<T>=T extends Array<infer U>?U:never
type T=[string,number]//规定T只能是number或者string
type uni=TYPE<boolean>//never