认识泛型

TypeScript也实现了类型于C#和Java的泛型以实现类型的参数化，我们先看一个需求：

1 function identity(arg: any): any {2     return arg;3 }

我们希望方法identity可以传入任意类型，并且返回传入的类型，这样写可以达到效果但是不能确定返回的类型，使用泛型的写法如下：

1 function identity
     
      (arg: T): T {2     return arg;3 }4 5 var output = identity
      
       ("myString");  // type of output will be 'string'6 var output = identity("myString");  // type of output will be 'string'
      
     

我们可以指定类型，也可以让编译器自动来识别类型。

泛型数组

我们也可以通过泛型来指定一个数组，写法如下：

1 function loggingIdentity
     
      (arg: T[]): T[] {2     console.log(arg.length);  // Array has a .length, so no more error3     return arg;4 }5 6 function loggingIdentity
      
       (arg: Array
       
        ): Array
        
          {7     console.log(arg.length);  // Array has a .length, so no more error8     return arg;9 }
        
       
      
     

泛型类型

我们可以指定一个带有泛型的函数：

1 function identity
     
      (arg: T): T {2     return arg;3 }4 5 var myIdentity: 
      (arg: U)=>U = identity;
     

还有另一种写法：

1 function identity
     
      (arg: T): T {2     return arg;3 }4 5 var myIdentity: {
      
       (arg: T): T} = identity;
      
     

使用函数接口的写法如下：

1 interface GenericIdentityFn {2     
     
      (arg: T): T;3 }4 5 function identity
      
       (arg: T): T {6     return arg;7 }8 9 var myIdentity: GenericIdentityFn = identity;
      
     

同时泛型还可以作为类型的参数而不是方法的参数，写法如下：

1 interface GenericIdentityFn
     
       {2     (arg: T): T;3 }4 5 function identity
      
       (arg: T): T {6     return arg;7 }8 9 var myIdentity: GenericIdentityFn
       
         = identity;
       
      
     

泛型类

泛型除了可以用在接口上以外，当然还可以用在类上：

1 class GenericNumber
     
       { 2     zeroValue: T; 3     add: (x: T, y: T) => T; 4 } 5  6 var myGenericNumber = new GenericNumber
      
       (); 7 myGenericNumber.zeroValue = 0; 8 myGenericNumber.add = function(x, y) { return x + y; }; 9 10 var stringNumeric = new GenericNumber
       
        ();11 stringNumeric.zeroValue = "";12 stringNumeric.add = function(x, y) { return x + y; };13 alert(stringNumeric.add(stringNumeric.zeroValue, "test"));
       
      
     

使用方法和C#与Java一致。

泛型约束

之前的泛型可以是任意的类型，我们还可以约束泛型的类型，我们先看一个会报错的例子：

1 function loggingIdentity
     
      (arg: T): T {2     console.log(arg.length);  // Error: T doesn't have .length3     return arg;4 }
     

报错原因是，类型T没有length属性，我们可以为类型T指定一个类型，如下：

1 interface Lengthwise {2     length: number;3 }4 5 function loggingIdentity
     
      (arg: T): T {6     console.log(arg.length);  // Now we know it has a .length property, so no more error7     return arg;8 }
     

写法是通过extends来指定类型T的类型必须是实现了Lengthwise接口的类型。

调用如下：

1 loggingIdentity(3);  // Error, number doesn't have a .length property2 loggingIdentity({length: 10, value: 3});

泛型约束泛型

某些情况下，我们可能会有如下的需求：

1 function find
     
      >(n: T, s: U) {   // errors because type parameter used in constraint2   // ...3 } 4 find (giraffe, myAnimals);
     

这种写法会报错，可以使用下面正确的写法来达到效果：

1 function find
     
      (n: T, s: Findable
      
       ) {   2   // ...3 } 4 find(giraffe, myAnimals);
      
     

在泛型中使用类类型

有时我们希望可以指定泛型的构造函数和属性，写法如下：

1 function create
     
      (c: {
   new(): T; }): T { 2     return new c();3 }
     

再看另外一个例子：

1 class BeeKeeper { 2     hasMask: boolean; 3 } 4  5 class ZooKeeper { 6     nametag: string;  7 } 8  9 class Animal {10     numLegs: number;11 }12 13 class Bee extends Animal {14     keeper: BeeKeeper;15 }16 17 class Lion extends Animal {18     keeper: ZooKeeper;19 }20 21 function findKeeper (a: {
   new(): A; 22     prototype: {keeper: K}}): K {23 24     return a.prototype.keeper;25 }26 27 findKeeper(Lion).nametag;  // typechecks!