盘点 TypeScript 内置类型

盘点 TypeScript 内置类型

当开发者开始学习 TypeScript 时，了解和理解内置类型是一个重要的步骤。TypeScript 提供了一系列内置类型，这些类型可以帮助我们更好地定义和使用变量、函数和对象。

首先，TypeScript 提供了基本的原始类型，包括 number、string、boolean、null和 undefined。这些类型可以用来声明变量的基本数据类型。

此外，TypeScript 还提供了一些更高级的内置类型，例如 Array、Tuple、Enum和 Any。Array类型用于定义数组，Tuple类型用于定义具有固定长度和特定类型的数组。Enum类型用于定义枚举类型，它允许我们为一组相关的常量赋予一个更友好的名称。Any类型是 TypeScript 中的顶级类型，它允许我们在编译时不进行类型检查。

TypeScript 还引入了一些更复杂的内置类型，例如 Object、Function 和 Promise。Object 类型用于描述非原始类型的变量，Function 类型用于描述函数，Promise 类型用于处理异步操作的结果。

此外，TypeScript 还提供了一些有用的内置类型，如 Date、RegExp 和 Error。Date 类型用于处理日期和时间，RegExp 类型用于处理正则表达式，Error 类型用于处理错误。

最后，TypeScript 还支持一些高级的类型操作符和类型推断，例如 union、intersection、type assertion 和 type inference。这些功能使得在 TypeScript 中定义和使用复杂类型变得更加灵活和强大。

了解和熟悉这些内置类型对于编写健壮、可维护和类型安全的 TypeScript 代码至关重要。通过合理地使用这些类型，我们可以在开发过程中更好地捕获错误、提高代码质量并减少调试时间。

本文将带大家了解 TypeScript 的一些高级类型的使用以及它的实现。

Partial

Partial用于将给定类型的所有属性设置为可选。换句话说，Partial 可以创建一个新的类型，该类型具有与原始类型相同的属性，但是这些属性都是可选的。

使用 Partial 可以很方便地定义一个对象，其中的属性可以选择性地进行赋值。这对于需要根据上下文动态设置对象属性的情况非常有用，或者当你想只更新对象的一部分属性时。

下面是一个例子，演示了如何使用 Partial 类型工具：

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

function updateUser(user: Partial<User>): void {
   
   
  // 更新用户信息
  // ...
}

const user: User = {
   
   
  name: "John",
  age: 30,
  email: "[email protected]"
};

updateUser({
   
    name: "John Doe" }); // 仅更新名称
updateUser({
   
    age: 31, email: "[email protected]" }); // 仅更新年龄和邮箱

在上面的例子中，我们定义了一个 User 接口，它具有 name、age 和 email 属性。然后，我们定义了一个 updateUser 函数，它接受一个 Partial<User> 类型的参数，即一个部分完成的 User 对象。

通过使用 Partial<User>，我们可以在调用 updateUser 函数时，只传递需要更新的属性，而不需要提供完整的 User 对象。这使得我们可以轻松地只更新用户的某些属性，而不必修改其他属性。

总之，Partial 类型工具是 TypeScript 中的一个有用工具，它可以帮助我们定义具有可选属性的对象类型，并在需要时方便地更新对象的部分属性。

下面我们来看看它的实现：

/**
 * Make all properties in T optional
 */
type Partial<T> = {
   
   
    [P in keyof T]?: T[P];
};

• type Partial<T>：通过 type 关键字定义了一个泛型类型 Partial<T>，其中 T 是一个类型参数，表示待处理的类型。
• [P in keyof T]?：使用索引类型查询操作符 keyof T 获取类型 T 的所有属性，并使用 in 关键字遍历这些属性。P 是遍历过程中的属性名，[P in keyof T] 表示在新类型中创建一个属性，属性名为 P。
• ?: T[P]：使用可选属性操作符 ? 将属性的值变为可选的。T[P] 表示在新类型中定义的属性的类型与原类型 T 对应属性的类型相同。

综合起来，Partial<T> 的作用是将类型 T 的所有属性转换为可选属性，即每个属性都可以有值或者不设置值。这个类型在实际开发中常用于对对象进行部分更新或者扩展，方便进行属性的选择性赋值。

Required

Required 用于将给定类型的所有属性设置为必需的。换句话说，Required 可以创建一个新的类型，该类型具有与原始类型相同的属性，但是这些属性都是必需的，不能省略。

使用 Required 可以很方便地定义一个对象，其中的属性必须进行赋值。这对于确保对象的完整性和类型安全非常有用。

下面是一个例子，演示了如何使用 Required 类型工具：

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

function createUser(user: Required<User>): void {
   
   
  // 创建用户
  // ...
}

createUser({
   
    name: "John", age: 30, email: "[email protected]" }); // 完整的用户信息
createUser({
   
    name: "John" }); // 缺少必需的属性，会报错

在上面的例子中，我们定义了一个 User 接口，它具有 name、age 和 email 属性，但是这些属性都是可选的，即可以省略。然后，我们定义了一个 createUser 函数，它接受一个 Required<User> 类型的参数，即一个必需的 User 对象。

通过使用 Required<User>，我们可以确保在调用 createUser 函数时，必须提供完整的 User 对象，而不能省略任何必需的属性。这有助于保证创建的用户对象具有所需的完整性和类型安全。

下面我们来看看它的实现：

/**
 * Make all properties in T required
 */
type Required<T> = {
   
   
    [P in keyof T]-?: T[P];
};

• type Required<T>：通过 type 关键字定义了一个泛型类型 Required<T>，其中 T 是一个类型参数，表示待处理的类型。
• [P in keyof T]-?：使用索引类型查询操作符 keyof T 获取类型 T 的所有属性，并使用 in 关键字遍历这些属性。P 是遍历过程中的属性名，[P in keyof T] 表示在新类型中创建一个属性，属性名为 P。
• -?: T[P]：使用必选属性操作符 -? 将属性的值变为必选的。T[P] 表示在新类型中定义的属性的类型与原类型 T 对应属性的类型相同。

综合起来，Required<T> 的作用是将类型 T 的所有属性转换为必选属性，即每个属性都必须有值。这个类型在实际开发中常用于对对象进行必要属性的约束，确保属性的完整性和正确性。

Readonly

Readonly用于将给定类型的所有属性设置为只读。换句话说，Readonly 可以创建一个新的类型，该类型具有与原始类型相同的属性，但是这些属性都是只读的，不能被修改。

使用 Readonly 可以很方便地定义一个只读的对象，其中的属性不能被修改。这对于确保对象的不可变性和类型安全非常有用。

下面是一个例子，演示了如何使用 Readonly 类型工具：

interface User {
   
   
  readonly name: string;
  readonly age: number;
  readonly email: string;
}

function getUser(): Readonly<User> {
   
   
  return {
   
    name: "John", age: 30, email: "[email protected]" };