typescript 内置工具

1.概述

TypeScript 提供了一系列内置的工具类型，这些工具类型可用于进行类型操作和变换。以下是一些常见的 TypeScript 内置工具类型：

1. Partial<T>：创建一个新类型，该类型包含了 T 类型的所有属性，但这些属性都变成了可选的。

2. Required<T>：与 Partial 相反，它创建一个新类型，该类型包含了 T 类型的所有属性，并使它们都变成了必选的。

3. Readonly<T>：创建一个新类型，该类型包含了 T 类型的所有属性，但这些属性都变成了只读，不可修改。

4. Record<K, T>：创建一个新类型，该类型代表一个对象，其属性名是 K 类型的值，而属性值是 T 类型。

5. Pick<T, K>：创建一个新类型，该类型包含了 T 类型的一组属性，这些属性由 K 类型指定。

6. Omit<T, K>：与 Pick 相反，它创建一个新类型，该类型包含了 T 类型的所有属性，除了由 K 类型指定的属性。

7. Exclude<T, U>：创建一个新类型，该类型包含了 T 类型中的所有值，但排除了 U 类型中的值。

8. Extract<T, U>：创建一个新类型，该类型包含了 T 类型中的所有值，但只包括 U 类型中的值。

9. NonNullable<T>：创建一个新类型，该类型排除了 T 类型中的 null 和 undefined。

10. ReturnType<T>：获取函数类型 T 的返回类型。

11. Parameters<T>：获取函数类型 T 的参数类型的元组。

12. InstanceType<T>：获取构造函数类型 T 的实例类型。

这些工具类型可以帮助你进行更复杂的类型操作，使代码更具可读性和可维护性。在需要对类型进行转换、操作或筛选时，内置工具类型是强大的辅助工具。

2.Partial(将一个类型 T 的所有属性变为可选属性)

Partial<T> 是 TypeScript 中的一个内置工具类型，用于将一个类型 T 的所有属性变为可选属性。 这在构建对象时特别有用，因为它允许你创建一个具有部分属性的对象，而不需要提供所有属性的值。

以下是 Partial 的示例：

interface Person {
  name: string;
  age: number;
  email: string;
}

type PartialPerson = Partial<Person>;

const partialPerson: PartialPerson = { name: "Alice" };
// 可以只提供 name 属性，其他属性是可选的

const anotherPartialPerson: PartialPerson = { age: 30 };
// 也可以只提供 age 属性，其他属性是可选的

const fullPerson: PartialPerson = {
  name: "Bob",
  age: 25,
  email: "bob@example.com",
};
// 也可以提供所有属性，但它们仍然是可选的

在上面的示例中，Partial<Person> 创建了一个新类型 PartialPerson，该类型包含 Person 类型的所有属性，但这些属性都变成了可选属性。这允许你创建具有不完整属性集的对象，而不违反类型检查。

Partial 在实际开发中通常用于处理可选属性，例如在表单处理和对象初始化中非常有用。

3.Required(用于将一个类型 T 的所有属性变为必选属性)

Required<T> 是 TypeScript 中的一个内置工具类型，用于将一个类型 T 的所有属性变为必选属性。这可以用来确保在构建对象或处理类型时，所有属性都必须提供值。

以下是 Required 的示例：

interface Person {
  name: string;
  age?: number;
  email?: string;
}

type RequiredPerson = Required<Person>;

const person: RequiredPerson = {
  name: "Alice",
  age: 30,
  email: "alice@example.com",
};
// 必须提供所有属性：name、age 和 email

const partialPerson: Person = { name: "Bob" };
// 在原始的 Person 类型中，age 和 email 是可选的

const anotherPartialPerson: Partial<Person> = { name: "Charlie" };
// 也可以使用 Partial<Person> 来表示可选属性

在上面的示例中，Required<Person> 创建了一个新类型 RequiredPerson，该类型包含 Person 类型的所有属性，但这些属性都变成了必选属性。这强制在构建 RequiredPerson 类型的对象时，必须提供所有属性。

Required 在某些情况下特别有用，例如在需要确保对象包含特定属性时，或者在需要强制要求所有属性都提供值时。

4.Readonly(它用于将给定类型 T 中的所有属性变为只读)

Readonly<T> 是 TypeScript 中的内置工具类型，它用于将给定类型 T 中的所有属性变为只读，阻止修改这些属性的值。这是一种很有用的方式，可以在确保对象不会被意外更改时使用。

以下是 Readonly 的示例：

interface Person {
  name: string;
  age: number;
}

type ReadonlyPerson = Readonly<Person>;

const person: ReadonlyPerson = { name: "Alice", age: 30 };
// 这里的 person 对象的属性 name 和 age 都是只读的

person.name = "Bob"; // 错误，不能修改只读属性

const anotherPerson: Readonly<Person> = { name: "Charlie", age: 25 };
anotherPerson.age = 26; // 错误，不能修改只读属性

在上面的示例中，Readonly<Person> 创建了一个新类型 ReadonlyPerson，该类型包含 Person 类型的所有属性，但这些属性都变成了只读。这意味着你不能在 ReadonlyPerson 对象上修改属性的值。

Readonly 在希望确保对象的属性不会被无意间更改时非常有用，它可以帮助你提高代码的可维护性和减少潜在的错误。

5.Record(创建具有一组特定属性的对象Record<K, T>)

Record<K, T> 是 TypeScript 中的内置工具类型，用于创建一个新类型，该类型代表一个对象，其中属性的名称来自于类型 K 中的值，而属性的类型为 T。它允许你轻松创建具有一组特定属性的对象。

以下是 Record 的示例：

type Student = {
  name: string;
  age: number;
};

// 创建一个记录，其中属性名来自于字符串类型 "subject"，属性类型为 Student
type SchoolRecord = Record<"subject", Student>;

const mathStudent: SchoolRecord = {
  subject: { name: "Alice", age: 20 },
};

const historyStudent: SchoolRecord = {
  subject: { name: "Bob", age: 22 },
};

// 使用 "subject" 属性名来访问 Student 对象
console.log(mathStudent.subject.name); // 输出 "Alice"

在上面的示例中，Record<"subject", Student> 创建了一个新类型 SchoolRecord，该类型有一个属性名为 "subject"，而属性类型为 Student。这使得你可以创建包含特定属性名和类型的对象。

Record 在需要创建包含一组特定属性的对象时非常有用，它可以帮助你确保对象的结构满足特定的要求。

6.Pick（允许你从一个类型中选择指定的属性，创建一个新的类型）

Pick 是 TypeScript 中的一个有用工具类型，它允许你从一个类型中选择指定的属性，创建一个新的类型。它的语法如下：

type NewType = Pick<SourceType, Keys>;

• NewType：新类型，包含了从 SourceType 中选择的属性。
• SourceType：源类型，你想要从中选择属性的类型。
• Keys：一个或多个属性名，你想要从 SourceType 中选择的属性名。

例如，如果你有一个包含多个属性的类型 Person：

type Person = {
  name: string;
  age: number;
  address: string;
};

你可以使用 Pick 来选择其中的一些属性，创建一个新的类型，比如：

type BasicInfo = Pick<Person, "name" | "age">;

现在，BasicInfo 类型只包含了 name 和 age 两个属性，而 address 被排除在外。这有助于在 TypeScript 中更精确地定义和使用类型，以确保类型安全。

7.Omit

8.Exclude

9.Extract

10.NonNullable

11.ReturnType

12.Parameters（用于获取函数类型的参数类型的元组）

Parameters 是 TypeScript 中的一个工具类型，它用于获取函数类型的参数类型的元组。这意味着，如果你有一个函数类型，你可以使用 Parameters 来获得该函数的参数类型的元组。

它的语法如下：

type Params = Parameters<FunctionType>;

• Params：一个元组类型，包含了函数类型 FunctionType 的参数类型。

例如，如果你有一个函数类型如下：

type AddFunction = (x: number, y: number) => number;

你可以使用 Parameters 来获取其参数类型的元组：

type AddFunctionParams = Parameters<AddFunction>;

现在，AddFunctionParams 将被推断为元组类型 [number, number]，这表示函数 AddFunction 接受两个 number 类型的参数。

这在一些类型安全的情况下非常有用，因为你可以使用这些参数类型来检查函数调用的正确性，以及对参数进行类型检查。

13.InstanceType