在先前的章节实作猜数字程序的时候,我们有用到 Promise<string> 这样的类型。在这个类型中,由小于 < 和大于 > 符号括起来的部份称为「泛型」(generic)。在「类型论」(type theory)中,「泛型」就是「参数多态」(parametric polymorphism),在定义类型的时候不去明确地指定具体的类型,而以参数的形式来传入类型,如此一来拥有泛型的类别和函数只需要实作一次,就可以透过参数传入不同类型的方式来将其应用在各种类型的数据下。

类别泛型

我们就实作出一个模拟堆栈(stack)空间的类别来练习泛型吧!代码如下:

class Stack {
    private data: any[] = [];

    push(element: any) {
        this.data.push(element);
    }

    pop() {
        return this.data.pop();
    }
}

以上实作了一个 Stack 类别,这个类别在被实体化之后会拥有一个私有的数组,并提供 push 和 pop 方法来操作这个数组。

我们可以撰写出以下程序,来将任意类型的值透过 push 方法存进 Stack 类别的对象中,再用 pop 方法将这些值取出。

class Stack {
    private data: any[] = [];
 
    push(element: any) {
        this.data.push(element);
    }
 
    pop() {
        return this.data.pop();
    }
}
 
const stack = new Stack();
 
stack.push(1);
stack.push("2");
stack.push(true);
 
console.log(stack.pop());
console.log(stack.pop());
console.log(stack.pop());

以上程序的运行结果如下:

true
2
1

目前的 Stack 类别对象可以存入任意类型的值,如果我们想要限制值的类型该怎么做呢?最直觉的方式就是利用前面的章节提到的对象转型方式,将 Stack 对象的类型转成其它类型。如下:

class Stack {
    private data: any[] = [];

    push(element: any) {
        this.data.push(element);
    }

    pop() {
        return this.data.pop();
    }
}

const numberStack: { push: (element: number) => void, pop: () => number } = new Stack();
const stringStack: { push: (element: string) => void, pop: () => string } = new Stack();
const booleanStack: { push: (element: boolean) => void, pop: () => boolean } = new Stack();

numberStack.push(1);
stringStack.push("2");
booleanStack.push(true);

console.log(booleanStack.pop());
console.log(stringStack.pop());
console.log(numberStack.pop());

这种作法虽然可行,但它不仅麻烦又很不安全。所以泛型的存在就很重要了,我们可以利用泛型,将以上程序改写为:

class Stack<T> {
    private data: T[] = [];

    push(element: T) {
        this.data.push(element);
    }

    pop() {
        return this.data.pop();
    }
}

const numberStack = new Stack<number>();
const stringStack = new Stack<string>();
const booleanStack = new Stack<boolean>();

numberStack.push(1);
stringStack.push("2");
booleanStack.push(true);

console.log(booleanStack.pop());
console.log(stringStack.pop());
console.log(numberStack.pop());

在 Stack 类别名称后加上泛型参数 T,就可以使用泛型参数 T 来代替类别内部用到的类型。使用 new 关键字来产生类别的实体对象时,若没有明确定义泛型参数的类型(例如只写 new Stack(),而不写 new Stack<number>()),且也没有在构造器的参数中被用到的泛型参数,编译器会自动将那些泛型参数推论为 unknown(稍后会介绍 unknown 与 any 的差异)。换句话说,如果在构造器参数中有用到泛型参数,则编译器会根据构造器被调用时实际传入参数的值的类型来自动推论泛型参数的实际类型。

一个类型可以使用多个泛型参数,用逗号 , 隔开即可。例如:

class Stack2D<X, Y> {
    private data: [X, Y][] = [];
 
    push(element: [X, Y]) {
        this.data.push(element);
    }
 
    pop() {
        return this.data.pop();
    }
}
 
const numberStack = new Stack2D<number, number>();
const stringStack = new Stack2D<string, string>();
const booleanStack = new Stack2D<boolean, boolean>();
 
const numberStringStack = new Stack2D<number, string>();
const stringNumberStack = new Stack2D<string, number>();
 
numberStack.push([1, 2]);
stringStack.push(["1", "2"]);
booleanStack.push([true, false]);
 
numberStringStack.push([1, "2"]);
stringNumberStack.push(["1", 2]);
 
console.log(stringNumberStack.pop());
console.log(numberStringStack.pop());
console.log(booleanStack.pop());
console.log(stringStack.pop());
console.log(numberStack.pop());

unknown 与 any 类型的差异

unknown 和 any 类型有点相像,它们都可以用来保存任意类型的值。

如下:

const a1: any = 1;
const a2: any = "2";
const a3: any = false;

const u1: unknown = 1;
const u2: unknown = "2";
const u3: unknown = false;

差异之处在于,any 类型的值可以被直接转型成其它任意类型,unknown 类型的值则需要靠 as 关键字来强制转型。

如下:

const a1: any = 1;
const a2: number = a1;

const u1: unknown = 1;
const u2: number = u1 as number;
const u3: number = u1; // compilation error

另外,unknown 类型的值无法直接作为操作数、对象或是函数,必须要先转型成其它可用类型才行。例如:

const a1: any = 1;
const a2: any = 2;
const a3 = a1 + a2;

const u1: unknown = 1;
const u2: unknown = 2;
const u3 = u1 as number + (u2 as number);
const u4 = u1 + u2; // compilation error

界面泛型

界面可以使用泛型。举例来说:

interface Point<T> {
    x: T,
    y: T
}

class Vertex<T> implements Point<T> {
    x: T;

    y: T;

    constructor(x: T, y: T) {
        this.x = x;
        this.y = y;
    }
}

函数泛型

函数也可以使用泛型,例如:

function reverse(items: any[]): any[] {
    const output = [];
    for (let i = items.length - 1;i >= 0;i--) {
        output.push(items[i]);
    }
    return output;
}

const a = [1, 3, 5, 7];
const a_rev = reverse(a);

a_rev[0] = "1";

以上的 reverse 函数,可以传入任意类型的数组,并将其反向。

我们可以发现,由于 reverse 函数回传的值的类型为 any[],而把原先的类型约束破坏掉了。替 reverse 函数加上泛型,就可以轻易地解决这个问题。程序如下:

function reverse<T>(items: T[]): T[] {
    const output = [];
    for (let i = items.length - 1;i >= 0;i--) {
        output.push(items[i]);
    }
    return output;
}

const a = [1, 3, 5, 7];
const a_rev = reverse(a);

a_rev[0] = "1"; // compilation Error

以上程序第 10 行,可以不必将调用 reverse 的表达式写成 reverse<number>(a),因为 TypeScript 的编译器会自动推论泛型参数 T 所代表的实际类型。(由于变量 a 的类型为 number[],因此泛型参数 T 会被自动推论为 number。)

匿名函数也可以使用泛型,程序如下:

const reverse = function <T> (items: T[]): T[] {
    const output = [];
    for (let i = items.length - 1;i >= 0;i--) {
        output.push(items[i]);
    }
    return output;
};

const a = [1, 3, 5, 7];
const a_rev = reverse(a);

a_rev[0] = "1"; // compilation Error

Lambda 语法的匿名函数也可以使用泛型,程序如下:

const reverse = <T>(items: T[]): T[] => {
    const output = [];
    for (let i = items.length - 1;i >= 0;i--) {
        output.push(items[i]);
    }
    return output;
};

const a = [1, 3, 5, 7];
const a_rev = reverse(a);

a_rev[0] = "1"; // compilation Error

泛型参数的默认值

前面有提到如果类别的泛型参数没有明确定义出来,且也未在构造器的参数中被使用到的话,就会被推论为 unknown。其实这点在使用有泛型的函数时也会发生,只不过比较少见。例如:

function f<T>(): T[] {
    return [];
}
 
const o = f();
 
o.push(1);
o.push("2");

以上的泛型参数 T 并未被用在 f 函数的参数中,所以会被编译器自动推论为 unknown。

如果要让编译器可以将这类的泛型参数自动推论为其它我们指定的类型,而不是 unknown 的话,可以在泛型参数名称后面加上 = 字符,再接上类型。

例如:

function f<T = number>(): T[] {
    return [];
}

const o = f();

o.push(1);
o.push("2"); // compilation Error

泛型参数的继承限定

在定义类型参数的时候,可以使用 extends 关键字来限定这个类型参数实际的类型一定要是哪一个类型,或是其子类型。

例如:

interface PointX {
    x: number
}
 
interface PointY {
    y: number
}
 
interface PointZ {
    z: number
}
 
interface Point2D extends PointX, PointY {
 
}
 
interface Point3D extends Point2D, PointZ {
 
}
 
class Vertex implements Point3D {
    x: number;

    y: number;

    z: number;
 
    constructor(x: number, y: number, z: number) {
        this.x = x;
        this.y = y;
        this.z = z;
    }
}
 
function getX<T extends PointX>(vertex: T): number {
    return vertex.x;
}
 
function getY<T extends PointY>(vertex: T): number {
    return vertex.y;
}
 
function getZ<T extends PointZ>(vertex: T): number {
    return vertex.z;
}
 
const v = new Vertex(1, 2, 3);
 
console.log(getX(v));
console.log(getY(v));
console.log(getZ(v));

以上程序的输出结果如下:

1
2
3

extends 关键字后面可以加上 keyof 关键字,再加上一个对象类型,就表示要将泛型参数限定为这个对象类型的属性键值的类型或是该类型的子类型。例如:

interface PointX {
    x: number
}
 
interface PointY {
    y: number
}
 
interface PointZ {
    z: number
}
 
interface Point2D extends PointX, PointY {
 
}
 
interface Point3D extends Point2D, PointZ {
 
}
 
class Vertex implements Point3D {
    x: number;

    y: number;

    z: number;
 
    constructor(x: number, y: number, z: number) {
        this.x = x;
        this.y = y;
        this.z = z;
    }
}
 
function getX<T extends PointX>(vertex: T): number {
    return vertex.x;
}
 
function getY<T extends PointY>(vertex: T): number {
    return vertex.y;
}
 
function getZ<T extends PointZ>(vertex: T): number {
    return vertex.z;
}
 
function get<T extends Vertex, K extends keyof Vertex>(vertex: T, key: K): number {
    return vertex[key];
}

事实上,泛型所用的 extends 和 keyof 关键字是可以直接被用在类型中的,这个我们会在之后的章节详细介绍。

总结

在这个章节中我们学会了 TypeScript 提供的泛型功能,它可以让我们的程序看起来更简洁,用起来也更安全。下一个章节,我们要来更深入地探讨 TypeScript 的类型。

下一章:高级的类型用法。