Skip to content

映射类型工具箱

中等 约 35 分钟

你将构建什么

一组重新实现 TypeScript 内置帮助器的工具类型,外加一个自定义的 DeepPartial,将所有嵌套属性变为可选。

学习目标

  • 使用 [K in keyof T] 语法遍历键
  • 用 ? 和 -? 添加或移除修饰符
  • 通过键过滤构建 Pick 和 Omit
  • 实现递归 DeepPartial

前置要求

  • 泛型类型
  • keyof 和索引访问类型
  • 条件类型(来自项目 11)

步骤

  1. 1

    构建 Partial 和 Readonly

    Partial<T> 将所有属性变为可选;Readonly<T> 将所有属性变为只读。两者都使用带修饰符的映射类型。

    代码
    type MyPartial<T> = { [K in keyof T]?: T[K]; };
    type MyReadonly<T> = { readonly [K in keyof T]: T[K]; };
    
    interface User { id: number; name: string; email: string; }
    
    type UserPartial = MyPartial<User>;   // { id?: number; name?: string; email?: string; }
    type UserReadonly = MyReadonly<User>; // readonly id, name, email

    预期结果

    UserPartial 允许部分对象;UserReadonly 禁止修改。

  2. 2

    构建 Required

    Required<T> 移除可选修饰符。使用 -? 从每个属性上剥离 ?。

    代码
    type MyRequired<T> = { [K in keyof T]-?: T[K]; };
    
    type MaybeUser = { id?: number; name?: string; };
    type RequiredUser = MyRequired<MaybeUser>; // { id: number; name: string; }

    预期结果

    RequiredUser 的所有属性都变为必填。

  3. 3

    构建 Pick 和 Omit

    Pick<T, K> 只保留 K 中的键;Omit<T, K> 移除它们。Pick 使用对 K 的映射类型;Omit 是 Pick + Exclude。

    代码
    type MyPick<T, K extends keyof T> = { [P in K]: T[P]; };
    type MyOmit<T, K extends keyof T> = MyPick<T, MyExclude<keyof T, K>>;
    
    type UserPreview = MyPick<User, 'id' | 'name'>;     // { id: number; name: string; }
    type UserWithoutId = MyOmit<User, 'id'>;             // { name: string; email: string; }

    预期结果

    UserPreview 只有 id 和 name;UserWithoutId 排除了 id。

  4. 4

    构建 Record

    Record<K, V> 创建一个键为 K、值为 V 的对象类型。使用对 K 的映射类型。

    代码
    type MyRecord<K extends keyof any, V> = { [P in K]: V; };
    
    type StringMap = MyRecord<string, number>;  // { [key: string]: number }
    type ThreeFlags = MyRecord<'a' | 'b' | 'c', boolean>; // { a: boolean; b: boolean; c: boolean; }

    预期结果

    StringMap 是索引签名;ThreeFlags 恰好有三个布尔键。

  5. 5

    构建 DeepPartial

    DeepPartial 递归地将所有属性变为可选,包括嵌套对象。使用条件类型检查值是否为对象。

    代码
    type DeepPartial<T> = {
      [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K];
    };
    
    interface Config {
      server: { port: number; host: string; };
      db: { url: string; pool: number; };
    }
    
    type PartialConfig = DeepPartial<Config>;
    // { server?: { port?: number; host?: string; }; db?: { url?: string; pool?: number; }; }
    
    const cfg: PartialConfig = { server: { port: 3000 } }; // OK — deeply partial

    预期结果

    PartialConfig 允许任意层级的部分嵌套。

自己动手试试

你学到了什么

你从零重建了 TypeScript 的内置工具类型 —— 理解它们让你能为任何对象形状创建自定义变换。

相关资源

相关课程

查阅不认识的术语

新手友好的术语表用大白话解释编程术语——变量、函数、DOM、Promise 等等。

查看术语表

解读错误信息

用大白话解释常见错误——什么意思、为什么发生、如何修复。

查看错误

← 返回主题