如何在TypeScript中使用泛型

泛型是TypeScript的一个重要特性，它允许你编写灵活的、可重用的组件，可以对多种类型进行操作。

泛型的主要目的是实现类型的参数化。在泛型中，我们使用类型参数来进行类型的参数化。

以下是一些使用TypeScript泛型的方法：

1. 定义一个函数，该函数可以操作任何类型的数组。

function identity<T>(arg: T[]): T[] {
    return arg;
}
 
let output = identity<string>(["1", "2", "3"]);  // type of output will be string[]

在这个例子中，我们定义了一个泛型函数identity，它接受一个类型参数T，并且接受一个T[]类型的参数。返回类型也是T[]。

2. 定义一个函数，该函数可以操作任何类型的两个参数。

function genericAdd<T>(a: T, b: T): T {
    return a + b;
}
 
let output = genericAdd<number>(1, 2);  // output will be 3
let output2 = genericAdd<string>("Hello ", "World");  // output2 will be "Hello World"

在这个例子中，我们定义了一个泛型函数genericAdd，它接受一个类型参数T，并且接受两个T类型的参数。返回类型也是T。

3. 定义一个泛型接口，该接口可以操作任何类型的对象。

interface GenericIdentity<T> {
    value: T;
}
 
let output: GenericIdentity<number> = { value: 1 };

在这个例子中，我们定义了一个泛型接口GenericIdentity，它接受一个类型参数T，并且接受一个T类型的属性value。

4. 定义一个泛型类，该类可以操作任何类型的对象。

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，它接受一个类型参数T，并且接受一个T类型的属性zeroValue和一个接收两个T类型参数并返回T类型结果的方法add。

5. 使用泛型约束来约束类型参数

function combine<T>(a: T, b: T) {
    return [a, b] as [T, T];
}
 
// 使用泛型约束
function genericRestrictions<T extends string | number>(a: T) {
    return a;
}
 
let output = genericRestrictions<number>(1);  // output will be number
let output2 = genericRestrictions<string>("Hello");  // output2 will be string

在这个例子中，我们定义了一个泛型函数genericRestrictions，它接受一个类型参数T，并且接受一个T类型的参数。但是，这里的T被约束为string | number，意味着T必须是string或者number类型。

6. 使用内部泛型类型

class Box<T> {
    value: T;
}
 
let box: Box<number> = new Box<number>();