参考
参考2
泛型（Generics）是指在定义函数、接口或类的时候，不预先指定具体的类型，而在使用的时候再指定类型的一种特性。
泛型使用
function func(arg: any): any {
return arg
}
这段代码编译不会报错，但是一个显而易见的缺陷是，它并没有准确的定义返回值的类型，而我们想要的是传入什么类型，返回值就是什么类型。
函数参数使用泛型
// <T> 相当于定义了类型T
function func<T>(arg: T): T {
return arg
}
func(10) // 不指定泛型类型，ts进行推断
func<string>('ssss') // 指定泛型类型(建议)
type 和 interface都可以定义函数类型，也用泛型来写一下，type 这么写：
type Print = <T>(arg: T) => T
const printFn:Print = function print(arg) {
console.log(arg)
return arg
}
interface 这么写：
interface Iprint<T> {
(arg: T): T
}
function print<T>(arg:T) {
console.log(arg)
return arg
}
const myPrint: Iprint<number> = print
默认参数
如果要给泛型加默认参数，可以这么写：
interface Iprint<T = number> {
(arg: T): T
}
function print<T>(arg:T) {
console.log(arg)
return arg
}
const myPrint: Iprint = print
这样默认就是 number 类型了，怎么样，是不是感觉 T 就如同函数参数一样呢？
多个类型参数
定义泛型的时候，可以一次定义多个类型参数：
function swap<T, U>(tuple: [T, U]): [U, T] {
return [tuple[1], tuple[0]];
}
swap<number, string>([7, 'seven']); // ['seven', 7]
上例中，我们定义了一个 swap 函数，用来交换输入的元组。
函数副作用操作
泛型不仅可以很方便地约束函数的参数类型，还可以用在函数执行副作用操作的时候。
比如我们有一个通用的异步请求方法，想根据不同的 url 请求返回不同类型的数据。
function request(url:string) {
return fetch(url).then(res => res.json())
}
调一个获取用户信息的接口：
request('user/info').then(res =>{
console.log(res)
})
这时候的返回结果 res 就是一个 any 类型，我们希望调用 API 都清晰的知道返回类型是什么数据结构，就可以这么做：
interface UserInfo {
name: string
age: number
}
function request<T>(url:string): Promise<T> {
return fetch(url).then(res => res.json())
}
request<UserInfo>('user/info').then(res =>{
console.log(res)
})
这样就能很舒服地拿到接口返回的数据类型，开发效率大大提高
泛型约束
在函数内部使用泛型变量的时候，由于事先不知道它是哪种类型，所以不能随意的操作它的属性或方法：
// 有参数length 属性（字符串、数组、对象key含length）
interface Inter {
length: number
}
function func3<T extends Inter>(a: T): number {
return a.length
}
func3('ssjsjjssj')
func3([1, 2, 3])
func3({
length: 3,
age: 99
})
泛型的应用场景
泛型约束类
定义一个栈，有入栈和出栈两个方法，如果想入栈和出栈的元素类型统一，就可以这么写：
class Stack<T> {
private data: T[] = []
push(item:T) {
return this.data.push(item)
}
pop():T | undefined {
return this.data.pop()
}
}
在定义实例的时候写类型，比如，入栈和出栈都要是 number 类型，就这么写：
const s1 = new Stack<number>()
这样，入栈一个字符串就会报错，特别注意的是，泛型无法约束类的静态成员。
泛型约束接口
使用泛型，也可以对 interface 进行改造，让 interface 更灵活。
interface IKeyValue<T, U> {
key: T
value: U
}
const k1:IKeyValue<number, string> = { key: 18, value: 'lin'}
const k2:IKeyValue<string, number> = { key: 'lin', value: 18}
泛型约束函数
function func<T>(arg: T): T {
return arg
}
func<string>('ssss') // 指定泛型类型(建议)
泛型定义数组
定义一个数组
const arr: Array<number> = [1,2,3]
Record 定义对象
Record 后面的泛型就是对象键和值的类型
let searchGroup: Record<string, string> = {}
