一、概述

映射对象类型（Mapped Types）是 TypeScript 中的一种高级类型，允许你基于已有类型创建新的类型。通过映射对象类型，你可以对类型进行转换、扩展和约束。本文将详细介绍映射对象类型的各种应用场景，并通过示例代码说明每个概念的使用方法。

二、什么是映射对象类型

映射对象类型使用一种特定的语法 { [P in K]: T } 来定义，其中 P 是类型变量，K 是键类型（通常是联合类型），T 是值类型。通过这种方式，你可以创建一个新的对象类型，其中键是 K 的成员，值是 T 类型。

示例

type Keys = "name" | "age" | "address";
type Person = { [K in Keys]: string };
let person: Person = {
    name: "Alice",
    age: "25",
    address: "123 Main St"
};

在上面的例子中，Person 类型是一个映射对象类型，键是 Keys 类型的成员，值是 string 类型。

使用场景

• 类型转换：当需要基于已有类型创建新类型时，如将对象的所有属性变为可选。
• 类型扩展：当需要在现有类型基础上进行扩展时，如增加额外的属性或方法。

type Optional<T> = {
    [P in keyof T]?: T[P];
};
interface PersonDetails {
    name: string;
    age: number;
    address: string;
}
type OptionalPersonDetails = Optional<PersonDetails>;
let optionalPerson: OptionalPersonDetails = {
    name: "Bob"
};

三、常用的映射对象类型

TypeScript 提供了一些内置的映射对象类型，可以用来简化常见的类型转换操作。

Partial<T>

Partial 类型将对象类型的所有属性变为可选。

interface User {
    id: number;
    name: string;
    email: string;
}
type PartialUser = Partial<User>;
let user: PartialUser = {
    name: "Alice"
};

Required<T>

Required 类型将对象类型的所有属性变为必选。

interface User {
    id?: number;
    name?: string;
    email?: string;
}
type RequiredUser = Required<User>;
let user: RequiredUser = {
    id: 1,
    name: "Alice",
    email: "alice@example.com"
};

Readonly<T>

Readonly 类型将对象类型的所有属性变为只读。

interface User {
    id: number;
    name: string;
    email: string;
}
type ReadonlyUser = Readonly<User>;
let user: ReadonlyUser = {
    id: 1,
    name: "Alice",
    email: "alice@example.com"
};
// user.id = 2; // Error: Cannot assign to 'id' because it is a read-only property.

Pick<T, K>

Pick 类型从对象类型中选择一组属性，创建新的子类型。

interface User {
    id: number;
    name: string;
    email: string;
}
type UserContactInfo = Pick<User, "name" | "email">;
let contactInfo: UserContactInfo = {
    name: "Alice",
    email: "alice@example.com"
};

Record<K, T>

Record 类型创建一个新的对象类型，其中键是 K 的成员，值是 T 类型。

type Role = "admin" | "user" | "guest";
type Permissions = Record<Role, string[]>;
let permissions: Permissions = {
    admin: ["read", "write", "delete"],
    user: ["read", "write"],
    guest: ["read"]
};

四、自定义映射对象类型

你还可以创建自己的映射对象类型，以满足特定的需求。

示例：将所有属性变为可空

type Nullable<T> = {
    [P in keyof T]: T[P] | null;
};
interface UserDetails {
    id: number;
    name: string;
    email: string;
}
type NullableUserDetails = Nullable<UserDetails>;
let user: NullableUserDetails = {
    id: null,
    name: "Alice",
    email: null
};

使用场景

• 特定类型转换：当需要对类型进行特定的转换时，如将所有属性变为可空。
• 灵活的数据结构：当需要灵活定义数据结构时，如根据条件动态生成类型。

type DefaultValues<T> = {
    [P in keyof T]?: T[P];
};
interface Config {
    host: string;
    port: number;
    secure: boolean;
}
type DefaultConfig = DefaultValues<Config>;
let config: DefaultConfig = {
    host: "localhost"
};

五、映射对象类型与泛型

映射对象类型与泛型结合使用，可以创建更加灵活和通用的类型定义。

示例

type ReadonlyPartial<T> = Readonly<Partial<T>>;
interface Settings {
    volume: number;
    brightness: number;
    theme: string;
}
type ReadonlyPartialSettings = ReadonlyPartial<Settings>;
let settings: ReadonlyPartialSettings = {
    volume: 50
};
// settings.volume = 60; // Error: Cannot assign to 'volume' because it is a read-only property.

使用场景

• 通用类型定义：当需要创建通用的类型定义时，如将任意类型的所有属性变为只读和可选。
• 复杂类型转换：当需要进行复杂的类型转换时，如结合多个映射类型进行转换。

type OptionalNullable<T> = {
    [P in keyof T]?: T[P] | null;
};
interface Profile {
    username: string;
    bio: string;
    avatarUrl: string;
}
type OptionalNullableProfile = OptionalNullable<Profile>;
let profile: OptionalNullableProfile = {
    username: "Alice",
    bio: null
};

结论

映射对象类型是 TypeScript 中的重要特性，提供了灵活且强大的类型转换方式。通过掌握内置映射对象类型（如 Partial、Required、Readonly、Pick 和 Record）以及自定义映射对象类型，你可以编写出更具通用性和可重用性的代码。在实际开发中，合理使用映射对象类型可以提高代码的类型安全性和可读性，帮助你更好地处理复杂的数据结构和类型操作。