关于javascript:TypeScript泛型

泛型：指在定义函数、接口、类时，不预先指定具体的类型，而是在应用的时候在指定类型的一种个性。
一、泛型函数

// 需要：封装一个函数，能够创立一个指定长度的数组，同时将每一项都填充一个默认值
//1、应用 any 类型
function getArr(val:any,len:number):any[]{const arr:any[] = []
    for(let i = 0; i<len; i++){arr.push(val)
    }
    return arr
}
const arr1 = getArr('abcde',3)
const arr2 = getArr(100.123,3)
console.log(arr1) //["abcde", "abcde", "abcde"]
console.log(arr2) //[100.123, 100.123, 100.123]
// 应用 any 类型后，会呈现 TS 动态查看体现不了的毛病，因而能够应用泛型来解决
//2、应用泛型 
function getArr2<T>(val:T,len:number): T[]{const arr:Array<T> = []
    for(let i = 0; i<len; i++){arr.push(val)
    }
    return arr
}
// 在调用函数时，应用 <> 手动指定类型，即便不指定类型，ts 也会主动推论出数据的类型
const arr3 = getArr2<number>(100.123,3)
const arr4 = getArr2<string>('abc',3)

多个泛型参数的函数：函数中有多个泛型的参数

function getMsg<K,V>(key:K,value:V){return [key,value]
} 
const arr = getMsg<string,number>('age',18)
console.log(arr) //['age',18]

二、泛型接口
在定义接口时，为接口中的属性或办法定义泛型类型，在应用接口时，再指定具体的泛型类型。
类的泛型接口

// 定义一个泛型接口 - 类
interface IBaseCRUD<T>{data: T[] // 含有 data 属性，一个元素类型为 T 的数组，用来存储数据信息
    add:(t:T)=>void // 含有增加数据信息的办法
    getById: (id: number) => T // 含有查找数据信息的办法
}
// 定义一个人类信息的类
class Person{
    id?:number
    name: string
    age: number
    constructor(name:string,age:number){
        this.name = name
        this.age = age
    }
}
// 定义一个满足 IBaseCRUD 接口可增加查找人类信息的类
class PersonCRUD implements IBaseCRUD<Person>{data: Array<Person> = [] // 初始化
    add(person:Person):void{
        // 主动生成 id
        //person.id = Date.now()+Math.random()
        person.id = this.data.length// 测试
        // 向 data 中增加人类信息
        this.data.push(person)
    }
    getById(id:number):Person{return this.data.find(person=>person.id === id)
    }
}

// 实例化 PersonCRUD
const personCRUD = new PersonCRUD
personCRUD.add(new Person('Liane',18))
personCRUD.add(new Person('Ann',16))
console.log(personCRUD.data)//[Person {name: "Liane", age: 18, id: 0},Person {name: "Ann", age: 16, id: 1}]
console.log(personCRUD.getById(0))//Person {name: "Liane", age: 18, id: 0}

函数的泛型接口

// 定义一个函数的泛型接口
interface IGetArr<T>{(val:T,len:number):Array<T>
}

// 定义一个合乎 IGetArr 接口的函数 -- 注：必须注明接口的类型
let getArr:IGetArr<any> = function<T>(val:T,len:number){let result:T[] = []// 默认值为[]
    for(let i = 0; i<len; i++){result[i] = val
    }
    return result
}
// 调用函数时不可能指定类型，否则会提醒谬误，因为该函数类型曾经是接口类型了
console.log(getArr<string>('a',3))// 提醒谬误
console.log(getArr('a',3))//['a','a','a']
console.log(getArr(123,3))//[123,123,123]

三、泛型类
一个类中的属性值的类型不确定，办法中的参数及返回值类型不确定的状况，能够定义泛型类

// 定义一个泛型类
class GenericNumber<T> {
    zeroValue: T;
    add: (x: T, y: T) => T;
}

let myGenericNumber = new GenericNumber<number>();
myGenericNumber.zeroValue = 0;
myGenericNumber.add = function(x, y) {return x + y;}; 

四、泛型束缚
在函数外部应用泛型变量的时候，因为当时不晓得它是那种类型，所以不能随便操作它的属性和办法。

function loggingIdentity<T>(arg: T): T {console.log(arg.length);
    return arg;
}

// index.ts(2,19): error TS2339: Property 'length' does not exist on type 'T'.

上例中，泛型 T 不肯定蕴含属性 length，所以编译的时候报错了。

这时，咱们能够对泛型进行束缚，只容许这个函数传入那些蕴含 length 属性的变量。这就是泛型束缚：

interface Lengthwise {length: number;}

function loggingIdentity<T extends Lengthwise>(arg: T): T {console.log(arg.length);
    return arg;
} 

上例中，咱们应用了 extends 束缚了泛型 T 必须合乎接口 Lengthwise 的形态，也就是必须蕴含 length 属性。

此时如果调用 loggingIdentity 的时候，传入的 arg 不蕴含 length，那么在编译阶段就会报错了：

interface Lengthwise {length: number;}

function loggingIdentity<T extends Lengthwise>(arg: T): T {console.log(arg.length);
    return arg;
}

loggingIdentity(7);

// index.ts(10,17): error TS2345: Argument of type '7' is not assignable to parameter of type 'Lengthwise'. 

多个类型参数之间也能够相互束缚：

function copyFields<T extends U, U>(target: T, source: U): T {for (let id in source) {target[id] = (<T>source)[id];
    }
    return target;
}

let x = {a: 1, b: 2, c: 3, d: 4};

copyFields(x, { b: 10, d: 20}); 

上例中，咱们应用了两个类型参数，其中要求 T 继承 U，这样就保障了 U 上不会呈现 T 中不存在的字段。