TypeScript 泛型：编写可重用代码的利器

泛型（Generics）是编程语言中一种强大的特性，允许在编译时使用类型参数来定义函数或类。在 TypeScript 中，泛型可以帮助开发人员编写可重用且类型安全的代码，从而减少代码重复，并提高代码的可读性和可维护性。

泛型函数

可以使用泛型来创建可接受不同类型参数的函数。例如，以下是一个使用泛型创建反转数组函数的示例：

function reverse<T>(list: T[]): T[] {
    const reversedList: T[] = [];

    for (let i = list.length - 1; i >= 0; i--) {
        reversedList.push(list[i]);
    }

    return reversedList;
}

const list1 = [1, 2, 3, 4, 5];
const list2 = ['a', 'b', 'c', 'd', 'e'];

console.log(reverse<number>(list1)); // Output: [5, 4, 3, 2, 1]
console.log(reverse<string>(list2)); // Output: ['e', 'd', 'c', 'b', 'a']

在上面的例子中，reverse 函数使用 <T> 定义了一个类型参数 T。这意味着函数可以接受任何类型（T）的数组作为参数，并返回相同类型的数组。在调用 reverse 时，我们通过<number> 和 <string> 指定了类型参数，告诉 TypeScript 要使用哪种类型。

泛型类

泛型还可以用于创建类。例如，以下是一个使用泛型创建栈类的示例：

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

    push(item: T) {
        this.items.push(item);
    }

    pop(): T | undefined {
        return this.items.pop();
    }
}

const stack1 = new Stack<number>();
stack1.push(1);
stack1.push(2);
stack1.push(3);

console.log(stack1.pop()); // Output: 3
console.log(stack1.pop()); // Output: 2
console.log(stack1.pop()); // Output: 1

const stack2 = new Stack<string>();
stack2.push('a');
stack2.push('b');
stack2.push('c');

console.log(stack2.pop()); // Output: 'c'
console.log(stack2.pop()); // Output: 'b'
console.log(stack2.pop()); // Output: 'a'

Stack 类使用 <T> 定义了一个类型参数 T，表示栈中存储的元素类型。通过指定类型参数，可以创建存储不同类型元素的栈。例如，new Stack<number>() 创建了一个存储数字类型的栈，而 new Stack<string>() 创建了一个存储字符串类型的栈。

总结

泛型是 TypeScript 中一项强大的功能，可以帮助开发人员编写可重用、类型安全、可读性强和可维护性高的代码。通过使用泛型，可以编写能够处理不同类型数据的函数和类，从而减少代码重复，并提高代码质量。