TypeScript 泛型

⒈介绍

　　软件工程中，我们不仅要创建一致的定义良好的API，同时也要考虑可重用性。泛型可用于提升代码的重用性，我们希望自己编写的代码，无论是模块还是组件，不仅能支持当前设计的数据类型，而且也能支持将来的数据类型，这在大型系统中是非常基础且重要的功能。所以我们常常能在各种各样的静态类型的语言中看到泛型设计，使用泛型来创建可重用的组件，一个组件可以支持多种类型的数据。 这样用户就可以以自己的数据类型来使用组件。

⒉泛型函数

　　我们创建一个hello函数，这个函数直接让传入的参数作为返回值return。

　　假设一个不使用泛型的函数会是什么样子？

　　如果传入参数是数字的话，它是这样的

function hello(arg:number) :number{
    return arg;
}

　　当我们的需求变成字符串时，它是这样的

function hello(arg:string) :string{
    return arg;
}

　　当然我们也可以使用any类型来表达这种混沌感

function hello(arg:any) :any{
    return arg;
}

　　但any类型并不能准确的表达返回值与参数必须是相同类型，因为any代表任何类型，这使得我们的类型表达开始混乱了。

　　因此，我们需要一种表达方式来控制函数的参数类型，这就要用到泛型了。

　　TypeScript的泛型语法非常主流，与Java || C#等静态类型语言的使用方式一致，就像下面这样：

function hello<T>(arg:T) :T{
    return arg;
}

　　我们给hello函数添加了泛型变量T，T代表用户即将传入的类型。类型既可以是number，也可以是string，而在最后，我们还使用T作为返回值的类型。这就达到了返回值和参数类型相同的目的，保持了函数表达的准确性。

　　我们定义了泛型函数后，可以用两种方法使用。 第一种是，使用熟悉的尖括号方式，传入所有的参数，包含类型参数：

let output = hello<string>("Hello TypeScript!");

　　这里我们明确的指定了T是string类型，并将它作为参数传给函数，需要注意的是指定类型使用了<>括起来而不是()。

　　第二种方法更普遍。利用了类型推断 -- TypeScript编译器会根据传入的参数类型自动地帮助我们确定T的类型：

let output = hello("Hello TypeScript!");

　　这个时候编译器会明确的知道T的类型就是参数“Hello TypeScript!”的类型string，同样返回值类型是T，也是string类型。

　　类型推断帮助我们精简了代码，也提高了可读性，让代码变得简洁。但凡事皆有例外，在某些特别复杂的情况下，如果编译器不能够自动地推断出类型的话，那么这个时候就需要我们非常明确的写出T的类型。

⒊泛型变量

　　创建hello这样的泛型函数时，编译器要求在函数体中正确的使用类型。这听起来像是一句废话，换言之，你必须把这些参数当成任意类型或所有类型。

　　让我们回顾以下hello这个函数

function hello<T>(arg:T) :T{
    return arg;
}

　　如果我们这个时候需要使用参数arg的长度时，就会出现下面这样尴尬的情况。

function hello<T>(arg: T): T {
    console.log(arg.length);  // Error: T doesn't have .length
    return arg;
}

　　编译器会非常迅速的进行报错，告诉我们泛型T并没有length这个属性。这似乎有点不合情理，如果T是string类型，那它是有length属性的。但如果T是number类型呢？就像木桶原理一样，编译器会选择最糟糕的情况进行处理，T代表任意类型，那么就一定会有最糟糕的情况。

　　什么情况下一定会有length属性呢？可以使用泛型数组来表达这样的情况。由于我们操作的是数组，所以length属性一定是存在的，那就可以像普通的数组一样操作它。

function hello<T>(arg: T[]): T[] {
    console.log(arg.length);  // Error: T doesn't have .length
    return arg;
}

　　这个时候我们再使用hello函数时就需要传入一个T的数组，也就是一个string变量的数组或者number变量的数组，而不是一个单纯的变量。返回值也是同类型的数组。这可以让我们把泛型变量T作为数组的一部分属性，而不是作为整体类型，这增加了灵活性。

　　不只是使用中括号，还可以使用Array来表达数组。

function hello<T>(arg: Array<T>): Array<T> {
    console.log(arg.length);  // Error: T doesn't have .length
    return arg;
}

⒋泛型类型　

　　在上面我们创建了hello通用函数，可以适用于不同的类型。 在这节，我们研究一下函数本身的类型，以及如何创建泛型接口。

　　泛型函数的类型与非泛型函数的类型没什么不同，只是有一个类型参数在最前面，像函数声明一样：

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

let myIdentity: <T>(arg: T) => T = identity;

　　我们也可以使用不同的泛型参数名，只要在数量上和使用方式上能对应上就可以。

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

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

　　我们还可以使用带有调用签名的对象字面量来定义泛型函数：

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

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

　　这引导我们去写第一个泛型接口了。 我们把上面例子里的对象字面量拿出来做为一个接口：

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

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

let myIdentity: GenericIdentityFn = identity;

　　一个相似的例子，我们可能想把泛型参数当作整个接口的一个参数。 这样我们就能清楚的知道使用的具体是哪个泛型类型（比如： Dictionary<string>而不只是Dictionary）。 这样接口里的其它成员也能知道这个参数的类型了。

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

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

let myIdentity: GenericIdentityFn<number> = identity;

　　注意，我们的示例做了少许改动。 不再描述泛型函数，而是把非泛型函数签名作为泛型类型一部分。 当我们使用 GenericIdentityFn的时候，还得传入一个类型参数来指定泛型类型（这里是：number），锁定了之后代码里使用的类型。 对于描述哪部分类型属于泛型部分来说，理解何时把参数放在调用签名里和何时放在接口上是很有帮助的。

　　除了泛型接口，我们还可以创建泛型类。 注意，无法创建泛型枚举和泛型命名空间。

⒌泛型类

　　泛型类看上去与泛型接口差不多。 泛型类使用（ <>）括起泛型类型，跟在类名后面。

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; };

　　GenericNumber类的使用是十分直观的，并且你可能已经注意到了，没有什么去限制它只能使用number类型。 也可以使用字符串或其它更复杂的类型。

let stringNumeric = new GenericNumber<string>();
stringNumeric.zeroValue = "";
stringNumeric.add = function(x, y) { return x + y; };

console.log(stringNumeric.add(stringNumeric.zeroValue, "test"));

　　与接口一样，直接把泛型类型放在类后面，可以帮助我们确认类的所有属性都在使用相同的类型。

　　我们在类那节说过，类有两部分：静态部分和实例部分。 泛型类指的是实例部分的类型，所以类的静态属性不能使用这个泛型类型。

⒍泛型约束

　　你应该会记得之前的一个例子，我们有时候想操作某类型的一组值，并且我们知道这组值具有什么样的属性。 在 hello例子中，我们想访问arg的length属性，但是编译器并不能证明每种类型都有length属性，所以就报错了。

function hello<T>(arg: T): T {
    console.log(arg.length);  // Error: T doesn't have .length
    return arg;
}

　　相比于操作any所有类型，我们想要限制函数去处理任意带有.length属性的所有类型。 只要传入的类型有这个属性，我们就允许，就是说至少包含这一属性。 为此，我们需要列出对于T的约束要求。

　　为此，我们定义一个接口来描述约束条件。 创建一个包含 .length属性的接口，使用这个接口和extends关键字来实现约束：

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;
}

　　现在这个泛型函数被定义了约束，因此它不再是适用于任意类型：

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

　　我们需要传入符合约束类型的值，必须包含必须的属性：

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

　　在泛型约束中使用类型参数

　　你可以声明一个类型参数，且它被另一个类型参数所约束。 比如，现在我们想要用属性名从对象里获取这个属性。 并且我们想要确保这个属性存在于对象 obj上，因此我们需要在这两个类型之间使用约束。

function getProperty(obj: T, key: K) {
    return obj[key];
}

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

getProperty(x, "a"); // okay
getProperty(x, "m"); // error: Argument of type 'm' isn't assignable to 'a' | 'b' | 'c' | 'd'.

　　在泛型里使用类类型

　　在TypeScript使用泛型创建工厂函数时，需要引用构造函数的类类型。比如，

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 createInstance<A extends Animal>(c: new () => A): A {
    return new c();
}

createInstance(Lion).keeper.nametag;  // typechecks!
createInstance(Bee).keeper.hasMask;   // typechecks!