TypeScript 类、泛型的使用实践 | 青训营

在TypeScript中，泛型是一种强大的功能，它允许在定义函数、类和接口时使用参数化类型。泛型使得开发人员可以创建可重用的组件，同时增加了代码的灵活性和安全性。

下面我列举了一些泛型的使用方法和场景，以及如何使用类型约束来增加代码的灵活性和安全性的实践记录：

• 创建可复用的函数： 使用泛型可以创建可复用的函数，这些函数可以在不同的类型上工作。例如，可以创建一个函数来翻转数组中的元素：

function reverseArray<T>(array: T[]): T[] {
  return array.reverse();
}

const numbers = [1, 2, 3, 4, 5];
const reversedNumbers = reverseArray(numbers); // [5, 4, 3, 2, 1]

const strings = ['hello', 'world'];
const reversedStrings = reverseArray(strings); // ['world', 'hello']

可以在函数定义中使用<T>定义类型参数，并在函数参数和返回值中使用它。这样一来，就可以使用相同的函数处理不同类型的数组。

• 类中使用泛型： 在类中使用泛型可以帮助创建可重用的类，可以在实例化时指定类型参数。例如，可以创建一个Stack类来实现一个栈数据结构：

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

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

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

const numberStack = new Stack<number>();
numberStack.push(1);
numberStack.push(2);
console.log(numberStack.pop()); // 2

const stringStack = new Stack<string>();
stringStack.push('hello');
stringStack.push('world');
console.log(stringStack.pop()); // 'world'

在上面的例子中，使用<T>定义了类型参数，并在类中的方法和属性中使用该参数。通过在实例化时指定类型参数，可以创建不同类型的栈实例。

• 泛型约束： 使用泛型约束可以进一步增加代码的灵活性和安全性。通过约束泛型类型，可以限制泛型参数的行为。

例如，可以创建一个函数来查找数组中的最小值，但要求数组中的元素类型必须实现Comparable接口：

interface Comparable {
  compareTo(other: this): number;
}

function findMin<T extends Comparable>(array: T[]): T | undefined {
  if (array.length === 0) return undefined;
  let min = array[0];
  for (let i = 1; i < array.length; i++) {
    if (array[i].compareTo(min) < 0) {
      min = array[i];
    }
  }
  return min;
}

在上面的例子中，使用<T extends Comparable>来约束泛型类型，要求它必须实现Comparable接口。在函数体内，可以使用compareTo方法比较元素之间的大小。

使用泛型约束可以提供更严格的类型检查，并减少潜在的错误。它能够在编译时捕获类型错误，同时提供了更好的代码提示和可读性。

在实践中，泛型可以应用于很多场景，例如函数、类、接口和类型别名等。使用泛型可以提高代码的复用性和灵活性，并且提供更好的类型安全性。深入理解和善于使用泛型，将有助于编写更健壮、可维护和类型安全的代码。