【Typescript】知识梳理:泛型

688 阅读4分钟

泛型基础

泛型(Generics)是指在定义函数、接口或类的时候,不预先指定具体的类型,而在使用的时候再指定类型的一种特性。

不用泛型,用any类型来定义函数:

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

使用any类型会导致这个函数可以接收任何类型的arg参数,这样就丢失了一些信息:传入的类型与返回的类型应该是相同的。 如果传入一个数字,只知道任何类型的值都有可能被返回。

因此,需要一种方法使返回值的类型与传入参数的类型是相同的。 这里使用了类型变量,它是一种特殊的变量,只用于表示类型而不是值。

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

identity添加了类型变量TT帮助捕获用户传入的类型(比如:number),并可以使用这个类型。 之后再次使用了T当做返回值类型。现在参数类型与返回值类型是相同的, 如此允许跟踪函数里使用的类型的信息。

定义了泛型函数后,可以用两种方法使用。 第一种是,传入所有的参数,包含类型参数:

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

这里明确的指定了Tstring类型,并做为一个参数传给函数,使用了<>括起来而不是()

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

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

此时没必要使用尖括号(<>)来明确地传入类型;编译器可以查看myString的值,然后把T设置为它的类型。 类型推论帮助保持代码精简和高可读性。

泛型定义

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

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;

多个类型参数

定义泛型的时候,可以一次定义多个类型参数。

function swap<T, U>(tuple: [T, U]): [U, T] {
    return [tuple[1], tuple[0]];
}
​
//定义了一个swap函数,用来交换输入的元组。
swap([7, 'seven']); // ['seven', 7]

泛型约束

在函数内部使用泛型变量的时候,由于事先不知道它是哪种类型,所以不能随意的操作它的属性或方法。

此时,我们可以对泛型进行约束,只允许这个函数传入那些包含 该属性的变量。这就是泛型约束。

interface Lengthwise {
    length: number;
}
​
function loggingIdentity<T extends Lengthwise>(arg: T): T {
    console.log(arg.length);
    return arg;
}

上例,也可以设为T类型的数组默认.length属性存在:

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

多个类型参数之间也可以互相约束:

//例中,使用了两个类型参数,其中要求 T 继承 U,这样就保证了 U 上不会出现 T 中不存在的字段。
function copyFields<T extends U, U>(target: T, source: U): T {
    for (let id in source) {
        target[id] = (<T>source)[id];
    }
    return target;
}
​
let x = { a: 1, b: 2, c: 3, d: 4 };
​
copyFields(x, { b: 10, d: 20 });

泛型接口

依据上例里的对象字面量拿出来做为一个接口:

interface GenericIdentityFn {
    <T>(arg: T): T;
}
​
function identity<T>(arg: T): T {
    return arg;
}
​
let myIdentity: GenericIdentityFn = identity;

上例,可以把泛型参数当作整个接口的一个参数:

interface GenericIdentityFn<T> {
    (arg: T): T;
}
​
function identity<T>(arg: T): T {
    return arg;
}
​
let myIdentity: GenericIdentityFn<number> = identity;

注意,此时在使用泛型接口的时候,需要定义泛型的类型。

泛型类

与泛型接口类似,泛型也可以用于类的类型定义中。

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

泛型参数的默认类型

在 TypeScript 2.3 以后,可以为泛型中的类型参数指定默认类型。当使用泛型时没有在代码中直接指定类型参数,从实际值参数中也无法推测出时,这个默认类型就会起作用。

function createArray<T = string>(length: number, value: T): Array<T> {
    let result: T[] = [];
    for (let i = 0; i < length; i++) {
        result[i] = value;
    }
    return result;
}

在泛型里使用类类型

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