typeScript ---泛型

泛型

可以使组件不仅能够支持当前的数据类型，同时也能够支持未来的数据类型。并且可以保证输入与输出的数据类型一致。

泛型函数

定义泛型函数

//泛型函数l类型声明
type IdentityFunc=<T>(arg:T)=>T;

//泛型函数声明
let identity:IdentityFunc=<T>(arg:T):T=>arg;

//===等价
function identity<T>(arg: T): T { 
    return arg;
}
let IdentityFunc: <T>(arg: T) => T = identity;

使用接口定义

interface IdentityFuncSame{
    <T>(arg: T): T;
}

//等价于对象字面量定义

function identity<T>(arg:T):T{

   retrun arg;

}

let IdentityFunc:{<T>:(arg:T):T}=identity

使用泛型函数

let output=identity<string>('Mary')

泛型类

定义泛型类

class GenericNumber<T>{
    zeroValue: T;
    add: (x: T, y: T) => T;
}

泛型约束 

//定义一个拥有length属性的类
interface LengthWise{
    length:Number;
}
function LoggingIdentity<T extends LengthWise>(arg:T):T{
       console.log(arg.length);
        return arg;
}

使用泛型类

let myGenericNumber = new GenericNumber<number>();
myGenericNumber.zeroValue = 1;
myGenericNumber.add = function (x, y) { return x * y };
let num=myGenericNumber.add(2, 2);
console.log(num);

使用构造函数

//定义构造函数类型的别名
type Tconstructor<T> = { new(name: string): T };
//或者采用接口定义方式
interface Iconstructor<T>{
    new(name:string):T;
}

//定义泛型函数
function create<T>(c:Tconstructor<T>,name:string ): T{
    return new c(name);
}

//定义一个Person类型
class Person { 
    constructor(private _name:string) { 
        this._name = _name;
    }
    public get name() {
        return this._name;
    }
}
const mary = create(Person, 'cc');
console.log(mary.name);