TypeScript 基础 泛型

Question

软件工程中，我们不仅要创建一致的定义良好的 API，同时也要考虑可重用性。 组件不仅能够支持当前的数据类型，同时也能支持未来的数据类型，这在创建大型系统时为你提供了十分灵活的功能。

在像 C#和 Java 这样的语言中，可以 使用 泛型 来创建可重用的组件，一个组件可以支持多种类型的数据 。 这样用户就可以以自己的数据类型来使用组件。

类型变量 T

// 使用泛型的例子：identity 函数
// 不用泛型的话，这个函数可能是下面这样：
function identity(arg: number): number {
    return arg;
}

// 或者使用 any 类型来定义函数：
function identity(arg: any): any {
    return arg;
}
// 使用 any 类型会导致这个函数可以接收任何类型的 arg 参数，这样就丢失了一些信息：传入的类型与返回的类型应该是相同的。如果我们传入一个数字，我们只知道任何类型的值都有可能被返回。

使用类型变量使得 返回值的类型 与 传入参数的类型 相同。类型变量是一种特殊的变量，只用于表示类型而不是值。

不同于使用 any ，它不会丢失信息

// 类型变量 T 帮助我们捕获用户传入的类型，之后再次使用了 T 当做返回值类型。现在参数类型与返回值类型是相同的了，这允许我们跟踪函数里使用的类型的信息。
function identity<T>(arg: T): T {
    return arg;
}

使用泛型函数方式一

第一种是，传入所有的参数，包含类型参数：

let output = identity<string>("myString");  // 输出的类型是 'string'

这里我们明确的指定了 T 是 string 类型，并做为一个参数传给函数，使用了 <> 括起来。

使用泛型函数方式二

利用了 类型推论 -- 即编译器会根据传入的参数自动地帮助我们确定 T 的类型：

let output = identity("myString");  // 输出的类型是 'string'

注意没必要使用尖括号（ <> ）来明确地传入类型；编译器可以查看 myString 的值，然后把 T 设置为它的类型。 类型推论帮助我们保持代码精简和高可读性。如果编译器不能够自动地推断出类型的话，只能像上面那样明确的传入 T 的类型，在一些复杂的情况下，这是可能出现的。

使用泛型变量

在函数体内必须把这些参数当做是任意或所有类型。

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

// 泛型函数 loggingIdentity，接收类型参数 T 和参数 arg，它是个元素类型是 T 的数组，并返回元素类型是 T 的数组。 如果我们传入数字数组，将返回一个数字数组，因为此时 T 的的类型为 number。 这可以让我们把泛型变量 T 当做类型的一部分使用，而不是整个类型，增加了灵活性。
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;
}

泛型约束

相比于操作 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});

使用 keyof 约束对象

其中使用了 TS 泛型和泛型约束。首先定义了 T 类型并使用 extends 关键字继承 object 类型的子类型，然后使用 keyof 操作符 获取 T 类型的所有键 ，它的返回 类型是 联合 类型 ，最后利用 extends 关键字约束 K 类型必须为 keyof T 联合类型的子类型

function prop<T, K extends keyof T>(obj: T, key: K) {
   return obj[key]
}


let o = { a: 1, b: 2, c: 3 }

prop(o, 'a') 
prop(o, 'd') //此时就会报错发现找不到，因为 k = "a" | "b" | "c"

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

声明一个类型参数，且它被另一个类型参数所约束。 比如，现在我们想要用属性名从对象里获取这个属性。 并且我们想要确保这个属性存在于对象 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'.

泛型类型<T>

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

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

# 也可以使用不同的泛型参数名，只要在数量上和使用方式上能对应上就可以
let myIdentity: <U>(arg: U) => U = identity;

# 还可以使用带有调用签名的对象字面量来定义泛型函数：
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;

泛型类

与接口一样， 泛型类使用（ <> ）括起泛型类型，跟在类名后面。可以帮助我们确认类的所有属性都在使用相同的类型。

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

// GenericNumber 类的使用是十分直观的，没有什么去限制它只能使用 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; };

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

在泛型里使用类类型

在 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!

小结

1. 使用类型变量 T 使得 返回值的类型 与 传入参数的类型 相同。类型变量是一种特殊的变量，只用于表示类型而不是值。
2. 泛型函数的函数体内必须把行参当做是任意或所有类型
3. 泛型接口、泛型类中，使用（ <> ）括起泛型类型跟在接口名和类名后面
4. 类有两部分：静态部分和实例部分。 泛型类指的是实例部分的类型，所以类的静态属性不能使用这个泛型类型。