认识泛型

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

 function identity(arg: any): any {

     return arg;

 }

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

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

     return arg;

 }

 var output = identity<string>("myString");  // type of output will be 'string'

 var output = identity("myString");  // type of output will be 'string'

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

泛型数组

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

 function loggingIdentity<T>(arg: T[]): T[] {

     console.log(arg.length);  // Array has a .length, so no more error

     return arg;

 }

 function loggingIdentity<T>(arg: Array<T>): Array<T> {

     console.log(arg.length);  // Array has a .length, so no more error

     return arg;

 }

泛型类型

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

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

     return arg;

 }

 var myIdentity: <U>(arg: U)=>U = identity;

还有另一种写法：

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

     return arg;

 }

 var myIdentity: {<T>(arg: T): T} = identity;

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

 interface GenericIdentityFn {

     <T>(arg: T): T;

 }

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

     return arg;

 }

 var myIdentity: GenericIdentityFn = identity;

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

 interface GenericIdentityFn<T> {

     (arg: T): T;

 }

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

     return arg;

 }

 var myIdentity: GenericIdentityFn<number> = identity;

泛型类

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

 class GenericNumber<T> {

     zeroValue: T;

     add: (x: T, y: T) => T;

 }

 var myGenericNumber = new GenericNumber<number>();

 myGenericNumber.zeroValue = 0;

 myGenericNumber.add = function(x, y) { return x + y; };

 var stringNumeric = new GenericNumber<string>();

 stringNumeric.zeroValue = "";

 stringNumeric.add = function(x, y) { return x + y; };

 alert(stringNumeric.add(stringNumeric.zeroValue, "test"));

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

泛型约束

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

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

     console.log(arg.length);  // Error: T doesn't have .length

     return arg;

 }

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

 interface Lengthwise {

     length: number;

 }

 function loggingIdentity<T extends Lengthwise>(arg: T): T {

     console.log(arg.length);  // Now we know it has a .length property, so no more error

     return arg;

 }

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

调用如下：

 loggingIdentity(3);  // Error, number doesn't have a .length property

 loggingIdentity({length: 10, value: 3});

泛型约束泛型

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

 function find<T, U extends Findable<T>>(n: T, s: U) {   // errors because type parameter used in constraint

   // ...

 }

 find (giraffe, myAnimals);

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

 function find<T>(n: T, s: Findable<T>) {

   // ...

 }

 find(giraffe, myAnimals);

在泛型中使用类类型

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

 function create<T>(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 extends Animal, K> (a: {new(): A;

     prototype: {keeper: K}}): K {

     return a.prototype.keeper;

 }

 findKeeper(Lion).nametag;  // typechecks!

巴特西

TypeScript学习笔记（六）：泛型