泛型是用来创建可重用的组件，使得一个组件可以支持多种类型的数据。

 一、泛型函数

//定义泛型函数
function identity(arg: T): T {
    return arg;
}
//使用方法
let output = identity("myString");  // string
let output = identity("myString");  // string  简写 返回值
let myIdentity:(arg: T) => T = identity; //函数
let myIdentity: {(arg: T): T} = identity; //写法等价
//参数长度，参数为number类型则没有长度
function loggingIdentity(arg:T[]):T[]{
    consoel.log(arg.length);
    return arg;
}

二、泛型接口

//接口1
interface GenericIdentityFn {(arg: T): T;
}

function identity(arg: T): T {
    return arg;
}

let myIdentity: GenericIdentityFn = identity;
//接口2
interface GenericIdentityFn{
    (arg: T): T;
}

function identity(arg: T): T {
    return arg;
}

let myIdentity: GenericIdentityFn= identity;

三、泛型类

//类有两部分：静态部分和实例部分。 泛型类指的是实例部分的类型，所以类的静态属性不能使用这个泛型类型。
class GenericNumber{
    zeroValue: T;
    add: (x: T, y: T) => T;
}

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

四、泛型约束

//定义一个接口来描述约束条件
interface Lengthwise {
    length: number;
}

function loggingIdentity(arg: T): T {
    console.log(arg.length);  // Now we know it has a .length property, so no more error
    return arg;
}
//可以声明一个类型参数，且它被另一个类型参数所约束
function find<T, U extends Findable>(n: T, s: U) {
  // ...
}
find (giraffe, myAnimals);
//类类型
function create(c: {new(): T; }): T {
    return new c();
}
//高级实例
class BeeKeeper {
    hasMask: boolean;
}

class ZooKeeper {
    nametag: string;
}

class Animal {
    numLegs: number;
}

class Bee extends Animal {
    keeper: BeeKeeper;
}

class Lion extends Animal {
    keeper: ZooKeeper;
}

function findKeeper (a: {new(): A;
    prototype: {keeper: K}}): K {

    return a.prototype.keeper;
}

findKeeper(Lion).nametag;  // typechecks!