掌握 TypeScript 的工具类型：这些强大的类型转换工具可以提高代码可复用性，并增强应用程式的类型安全性。
TypeScript 工具类型：内置的类型操作工具
TypeScript 是一门功能强大的语言，它为 JavaScript 带来了静态类型。其关键特性之一是能够操作类型，让开发者可以创建更健壮、更易于维护的代码。TypeScript 提供了一套内置的工具类型，可以简化常见的类型转换。这些工具类型是增强类型安全、提高代码可复用性以及简化开发工作流程的宝贵工具。本综合指南将探讨最重要的 TypeScript 工具类型，提供实用的示例和可行的见解，帮助您掌握它们。
什么是 TypeScript 工具类型？
工具类型是预定义的类型操作符，可将现有类型转换为新类型。它们内置于 TypeScript 语言中，提供了一种简洁且声明式的方式来执行常见的类型操作。使用工具类型可以显著减少样板代码，并使您的类型定义更具表现力、更易于理解。
您可以将它们看作是作用于类型而非值的函数。它们以一个类型作为输入，并返回一个修改后的类型作为输出。这使您能够用最少的代码创建复杂的类型关系和转换。
为什么要使用工具类型？
在您的 TypeScript 项目中整合工具类型有几个令人信服的理由：
- 增强类型安全：工具类型可帮助您强制执行更严格的类型约束，从而减少运行时错误的可能性，并提高代码的整体可靠性。
- 提高代码可复用性：通过使用工具类型，您可以创建适用于多种类型的泛型组件和函数，从而促进代码重用并减少冗余。
- 减少样板代码：工具类型提供了一种简洁且声明式的方式来执行常见的类型转换，从而减少了您需要编写的样板代码量。
- 增强可读性：工具类型使您的类型定义更具表现力、更易于理解，从而提高了代码的可读性和可维护性。
核心 TypeScript 工具类型
让我们来探讨一些 TypeScript 中最常用和最有益的工具类型。我们将介绍它们的用途、语法，并提供实际示例以说明其用法。
1. Partial<T>
Partial<T> 工具类型将类型 T 的所有属性变为可选。当您想创建一个新类型，它具有现有类型的某些或全部属性，但又不要求所有属性都存在时，这非常有用。
语法：
type Partial<T> = { [P in keyof T]?: T[P]; };
示例：
interface User {
id: number;
name: string;
email: string;
}
type OptionalUser = Partial<User>; // 所有属性现在都是可选的
const partialUser: OptionalUser = {
name: "Alice", // 只提供了 name 属性
};
使用场景：仅更新对象的某些属性。例如，想象一个用户个人资料更新表单，您不希望要求用户一次性更新所有字段。
2. Required<T>
Required<T> 工具类型将类型 T 的所有属性变为必需。它与 Partial<T> 相反。当您有一个带有可选属性的类型，并希望确保所有属性都存在时，这非常有用。
语法：
type Required<T> = { [P in keyof T]-?: T[P]; };
示例：
interface Config {
apiKey?: string;
apiUrl?: string;
}
type CompleteConfig = Required<Config>; // 所有属性现在都是必需的
const config: CompleteConfig = {
apiKey: "your-api-key",
apiUrl: "https://example.com/api",
};
使用场景：在启动应用程序前，强制要求提供所有配置设置。这有助于防止因缺少或未定义的设置而导致的运行时错误。
3. Readonly<T>
Readonly<T> 工具类型将类型 T 的所有属性变为只读。这可以防止您在对象创建后意外修改其属性。这有助于促进不可变性，并提高代码的可预测性。
语法：
type Readonly<T> = { readonly [P in keyof T]: T[P]; };
示例：
interface Product {
id: number;
name: string;
price: number;
}
type ImmutableProduct = Readonly<Product>; // 所有属性现在都是只读的
const product: ImmutableProduct = {
id: 123,
name: "Example Product",
price: 25.99,
};
// product.price = 29.99; // 错误：无法分配到 'price'，因为它是只读属性。
使用场景：创建不可变的数据结构，例如配置对象或数据传输对象 (DTO)，这些对象在创建后不应被修改。这在函数式编程范式中尤其有用。
4. Pick<T, K extends keyof T>
Pick<T, K extends keyof T> 工具类型通过从类型 T 中选取一组属性 K 来创建一个新类型。当您只需要现有类型的属性子集时，这非常有用。
语法：
type Pick<T, K extends keyof T> = { [P in K]: T[P]; };
示例：
interface Employee {
id: number;
name: string;
department: string;
salary: number;
}
type EmployeeNameAndDepartment = Pick<Employee, "name" | "department">; // 只选取 name 和 department
const employeeInfo: EmployeeNameAndDepartment = {
name: "Bob",
department: "Engineering",
};
使用场景：创建只包含特定操作所需数据的专用数据传输对象 (DTO)。这可以提高性能并减少通过网络传输的数据量。想象一下，向客户端发送用户详细信息，但排除了像薪水这样的敏感信息。您可以使用 Pick 只发送 `id` 和 `name`。
5. Omit<T, K extends keyof any>
Omit<T, K extends keyof any> 工具类型通过从类型 T 中省略一组属性 K 来创建一个新类型。它与 Pick<T, K extends keyof T> 相反，当您想从现有类型中排除某些属性时非常有用。
语法：
type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;
示例：
interface Event {
id: number;
title: string;
description: string;
date: Date;
location: string;
}
type EventSummary = Omit<Event, "description" | "location">; // 省略 description 和 location
const eventPreview: EventSummary = {
id: 1,
title: "Conference",
date: new Date(),
};
使用场景：为特定目的创建数据模型的简化版本，例如显示事件摘要而不包括完整的描述和位置。这也可用于在将数据发送到客户端之前删除敏感字段。
6. Exclude<T, U>
Exclude<T, U> 工具类型通过从 T 中排除所有可分配给 U 的类型来创建一个新类型。当您想从联合类型中移除某些类型时，这非常有用。
语法：
type Exclude<T, U> = T extends U ? never : T;
示例：
type AllowedFileTypes = "image" | "video" | "audio" | "document";
type MediaFileTypes = "image" | "video" | "audio";
type DocumentFileTypes = Exclude<AllowedFileTypes, MediaFileTypes>; // "document"
const fileType: DocumentFileTypes = "document";
使用场景：过滤联合类型以移除在特定上下文中不相关的特定类型。例如，您可能希望从允许的文件类型列表中排除某些文件类型。
7. Extract<T, U>
Extract<T, U> 工具类型通过从 T 中提取所有可分配给 U 的类型来创建一个新类型。它与 Exclude<T, U> 相反，当您想从联合类型中选择特定类型时非常有用。
语法：
type Extract<T, U> = T extends U ? T : never;
示例：
type InputTypes = string | number | boolean | null | undefined;
type PrimitiveTypes = string | number | boolean;
type NonNullablePrimitives = Extract<InputTypes, PrimitiveTypes>; // string | number | boolean
const value: NonNullablePrimitives = "hello";
使用场景：根据特定条件从联合类型中选择特定类型。例如，您可能希望从包含基本类型和对象类型的联合类型中提取所有基本类型。
8. NonNullable<T>
NonNullable<T> 工具类型通过从类型 T 中排除 null 和 undefined 来创建一个新类型。当您想确保一个类型不能为 null 或 undefined 时，这非常有用。
语法：
type NonNullable<T> = T extends null | undefined ? never : T;
示例：
type MaybeString = string | null | undefined;
type DefinitelyString = NonNullable<MaybeString>; // string
const message: DefinitelyString = "Hello, world!";
使用场景：在对一个值执行操作之前，强制该值不为 null 或 undefined。这有助于防止由意外的 null 或 undefined 值引起的运行时错误。考虑一个场景，您需要处理用户的地址，并且在任何操作之前确保地址不为 null 至关重要。
9. ReturnType<T extends (...args: any) => any>
ReturnType<T extends (...args: any) => any> 工具类型提取函数类型 T 的返回类型。当您想知道函数返回值的类型时，这非常有用。
语法：
type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;
示例：
function fetchData(url: string): Promise<{ data: any }> {
return fetch(url).then(response => response.json());
}
type FetchDataReturnType = ReturnType<typeof fetchData>; // Promise<{ data: any }>
async function processData(data: FetchDataReturnType) {
// ...
}
使用场景：确定函数返回值的类型，尤其是在处理异步操作或复杂函数签名时。这使您能够确保正确处理返回的值。
10. Parameters<T extends (...args: any) => any>
Parameters<T extends (...args: any) => any> 工具类型以元组的形式提取函数类型 T 的参数类型。当您想知道函数接受的参数类型时，这非常有用。
语法：
type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never;
示例：
function createUser(name: string, age: number, email: string): void {
// ...
}
type CreateUserParams = Parameters<typeof createUser>; // [string, number, string]
function logUser(...args: CreateUserParams) {
console.log("Creating user with:", args);
}
使用场景：确定函数接受的参数类型，这在创建需要与不同签名的函数一起工作的泛型函数或装饰器时非常有用。它有助于在动态地将参数传递给函数时确保类型安全。
11. ConstructorParameters<T extends abstract new (...args: any) => any>
ConstructorParameters<T extends abstract new (...args: any) => any> 工具类型以元组的形式提取构造函数类型 T 的参数类型。当您想知道构造函数接受的参数类型时，这非常有用。
语法：
type ConstructorParameters<T extends abstract new (...args: any) => any> = T extends abstract new (...args: infer P) => any ? P : never;
示例：
class Logger {
constructor(public prefix: string, public enabled: boolean) {}
log(message: string) {
if (this.enabled) {
console.log(`${this.prefix}: ${message}`);
}
}
}
type LoggerConstructorParams = ConstructorParameters<typeof Logger>; // [string, boolean]
function createLogger(...args: LoggerConstructorParams) {
return new Logger(...args);
}
使用场景：与 Parameters 类似，但专门用于构造函数。当创建工厂或依赖注入系统，需要动态实例化具有不同构造函数签名的类时，它很有帮助。
12. InstanceType<T extends abstract new (...args: any) => any>
InstanceType<T extends abstract new (...args: any) => any> 工具类型提取构造函数类型 T 的实例类型。当您想知道构造函数创建的对象的类型时，这非常有用。
语法：
type InstanceType<T extends abstract new (...args: any) => any> = T extends abstract new (...args: any) => infer R ? R : any;
示例：
class Greeter {
greeting: string;
constructor(message: string) {
this.greeting = message;
}
greet() {
return "Hello, " + this.greeting;
}
}
type GreeterInstance = InstanceType<typeof Greeter>; // Greeter
const myGreeter: GreeterInstance = new Greeter("World");
console.log(myGreeter.greet());
使用场景：确定由构造函数创建的对象的类型，这在处理继承或多态时非常有用。它提供了一种类型安全的方式来引用类的实例。
13. Record<K extends keyof any, T>
Record<K extends keyof any, T> 工具类型构造一个对象类型，其属性键为 K，属性值为 T。这对于创建预先知道键的类字典类型非常有用。
语法：
type Record<K extends keyof any, T> = { [P in K]: T; };
示例：
type CountryCode = "US" | "CA" | "GB" | "DE";
type CurrencyMap = Record<CountryCode, string>; // { US: string; CA: string; GB: string; DE: string; }
const currencies: CurrencyMap = {
US: "USD",
CA: "CAD",
GB: "GBP",
DE: "EUR",
};
使用场景：创建类字典对象，其中您有一组固定的键，并希望确保所有键都具有特定类型的值。这在处理配置文件、数据映射或查找表时很常见。
自定义工具类型
虽然 TypeScript 的内置工具类型功能强大，但您也可以创建自己的自定义工具类型来解决项目中的特定需求。这使您能够封装复杂的类型转换并在整个代码库中重用它们。
示例：
// 一个工具类型，用于获取对象中具有特定类型的键
type KeysOfType<T, U> = { [K in keyof T]: T[K] extends U ? K : never }[keyof T];
interface Person {
name: string;
age: number;
address: string;
phoneNumber: number;
}
type StringKeys = KeysOfType<Person, string>; // "name" | "address"
使用工具类型的最佳实践
- 使用描述性名称：为您的工具类型指定有意义的名称，以清楚地表明其用途。这可以提高代码的可读性和可维护性。
- 为您的工具类型编写文档：添加注释来解释您的工具类型的作用以及应如何使用它们。这有助于其他开发人员理解您的代码并正确使用它。
- 保持简单：避免创建难以理解的过于复杂的工具类型。将复杂的转换分解为更小、更易于管理的工具类型。
- 测试您的工具类型：编写单元测试以确保您的工具类型正常工作。这有助于防止意外错误，并确保您的类型按预期运行。
- 考虑性能：虽然工具类型通常不会对性能产生重大影响，但要注意类型转换的复杂性，尤其是在大型项目中。
结论
TypeScript 工具类型是强大的工具，可以显著提高代码的类型安全、可复用性和可维护性。通过掌握这些工具类型，您可以编写更健壮、更具表现力的 TypeScript 应用程序。本指南涵盖了最重要的 TypeScript 工具类型，提供了实际示例和可行的见解，以帮助您将它们整合到您的项目中。
请记住，要多尝试这些工具类型，并探索如何利用它们来解决您自己代码中的特定问题。随着您对它们越来越熟悉，您会发现自己越来越多地使用它们来创建更清晰、更易于维护、类型更安全的 TypeScript 应用程序。无论您是在构建 Web 应用程序、服务器端应用程序还是介于两者之间的任何应用，工具类型都为改进您的开发工作流程和代码质量提供了一套宝贵的工具。通过利用这些内置的类型操作工具，您可以释放 TypeScript 的全部潜力，并编写出既具表现力又稳健的代码。