TypeScript 类、泛型的使用实践记录：探讨泛型使用及使用类型约束增加代码安全性和灵活性

TypeScript 泛型的使用实践与类型约束

TypeScript 是一种强类型的 JavaScript 超集，它提供了许多功能来增强代码的可维护性和安全性。泛型（Generics）是 TypeScript 中的一项强大特性，它使得我们可以编写更加灵活、可重用且类型安全的代码。在本文中，我们将探讨 TypeScript 中泛型的使用方法和场景，并通过类型约束来增加代码的灵活性和安全性。

一、什么是泛型？

泛型是指在定义函数、类或接口时，不指定具体的类型，而是用一个占位符来代替具体类型，从而实现对多种类型的支持。在实际应用中，泛型能使得我们的代码更加通用和复用。

例如，在 TypeScript 中，我们可以用 T 作为占位符来表示类型，而在调用时，指定实际的类型：

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

上面的 identity 函数就是一个泛型函数，它接受一个参数 arg，其类型是 T，返回值类型也是 T。当我们调用 identity 函数时，可以传入任何类型的参数，TypeScript 会自动推断出 T 的具体类型：

let result1 = identity(5);       // result1 的类型是 number
let result2 = identity("hello"); // result2 的类型是 string

二、泛型的实际应用场景

函数的泛型
泛型最常见的应用场景之一是在函数中，尤其是当函数需要处理不同类型的输入时。比如，数组去重的实现：

function removeDuplicates<T>(arr: T[]): T[] {
  return [...new Set(arr)];
}

const numbers = [1, 2, 3, 4, 4, 5];
const uniqueNumbers = removeDuplicates(numbers); // 类型为 number[]

const strings = ["apple", "banana", "apple"];
const uniqueStrings = removeDuplicates(strings); // 类型为 string[]

类的泛型
泛型还可以用于类的定义，允许类处理不同类型的数据。例如，我们可以定义一个泛型类来管理数据：

class Box<T> {
  private value: T;

  constructor(value: T) {
    this.value = value;
  }

  getValue(): T {
    return this.value;
  }

  setValue(value: T): void {
    this.value = value;
  }
}

const numberBox = new Box<number>(123);
const stringBox = new Box<string>("hello");

console.log(numberBox.getValue()); // 123
console.log(stringBox.getValue()); // "hello"

接口的泛型
泛型还可以用于接口定义，尤其是在描述容器类、函数类型、异步操作等场景中。例如，我们可以使用泛型接口定义一个通用的“响应”接口：

interface Response<T> {
  data: T;
  status: number;
}

const userResponse: Response<{ name: string, age: number }> = {
  data: { name: "Alice", age: 25 },
  status: 200
};

const stringResponse: Response<string> = {
  data: "Success",
  status: 200
};

三、类型约束与泛型

泛型虽然非常灵活，但有时我们需要通过类型约束来确保泛型类型满足某些条件，这样可以增强代码的安全性。例如，假设我们想要限制某个泛型参数 T 必须是一个数组：

function logArrayLength<T extends Array<any>>(arr: T): void {
  console.log(arr.length);
}

logArrayLength([1, 2, 3]);  // 合法
logArrayLength("hello");    // 错误，"hello" 不是一个数组

在上面的代码中，T extends Array<any> 表示泛型 T 必须是一个数组类型。如果我们传入非数组类型，TypeScript 会给出编译错误。

另外，TypeScript 支持多个约束条件，我们可以同时对泛型参数应用多个约束：

interface Lengthwise {
  length: number;
}

function logLength<T extends Lengthwise>(arg: T): void {
  console.log(arg.length);
}

logLength([1, 2, 3]);       // 合法，数组有 length 属性
logLength("hello world");   // 合法，字符串有 length 属性
logLength(123);             // 错误，数字没有 length 属性

通过这种方式，我们确保了泛型 T 必须满足 Lengthwise 接口，即具有 length 属性。

四、泛型与联合类型

在某些场景下，我们可能希望一个泛型参数能够支持多种类型。此时，联合类型（|）可以与泛型结合使用，提供更多的灵活性。例如，定义一个既可以接收字符串也可以接收数字的函数：

function logValue<T extends string | number>(value: T): void {
  console.log(value);
}

logValue(123);      // 合法
logValue("hello");  // 合法
logValue(true);     // 错误，布尔值不符合类型约束

五、总结

泛型是 TypeScript 中一个非常重要且强大的功能，它使得代码更具灵活性和可复用性。在实际应用中，泛型常常与类型约束一起使用，以确保代码的安全性和可维护性。通过合理使用泛型和类型约束，我们可以编写出更加通用、灵活和类型安全的代码。

泛型不仅可以用于函数、类和接口的定义，还可以通过类型约束来精确控制泛型类型的可用范围，从而减少类型错误的发生。在日常开发中，充分理解和利用泛型，可以帮助我们写出更加简洁和高效的 TypeScript 代码。

TypeScript 类、泛型的使用实践记录：探讨泛型使用及使用类型约束增加代码安全性和灵活性 | 豆包MarsCode AI刷题