罗罗编程学习记录
本页内容 展开查看

03.3.1.4 类型体操与工具类型

所属:全栈开发面试题库 / 03 前端基础与 Web 开发 / 03.3 TypeScript / 03.3.1 类型系统与工程实践

03.3.1.4-001 Partial<T> 与 Required<T> 分别做什么?

一句话结论

Partial<T> 把所有属性变为可选;Required<T> 把所有可选属性变为必填,二者是映射类型在可选修饰符上的双向操作。

概念解释

  • Partial 加 ?,Required 用 -? 移除可选。
  • 二者都是浅层转换,嵌套对象内部不变。
  • 数组元素类型不在这两个工具的转换范围内。

原理流程

  1. 遍历 keyof T。
  2. Partial 为每个属性加可选修饰;Required 移除可选。
  3. 返回新对象类型。

代码 / 示例

interface User { id: number; name?: string; age?: number }
type Draft = Partial<User>;   // id?: number; name?: string; age?: number
type Full = Required<User>;   // id: number; name: string; age: number

常见误区

  • 误区:Partial 递归把嵌套对象也变可选;正解:内置 Partial 只处理一层,深层需递归实现。
  • 误区:Required 会把只读属性去掉;正解:它只处理可选性,不影响 readonly。

追问

  • Q:如何实现深层可选? A:递归映射,对象值继续套 DeepPartial,见 03.3.1.4-008。
  • Q:Partial 与可选链配合使用场景? A:表单草稿、局部更新请求体等只传部分字段的场景。

03.3.1.4-002 Pick<T, K> 与 Omit<T, K> 如何工作?

一句话结论

Pick 从 T 中选取指定键组成新类型;Omit 排除指定键保留其余,Omit 内部由 Pick 与 Exclude 组合实现。

概念解释

  • Pick 的 K 必须是 keyof T 的子集。
  • Omit 的 K 可以是任意字符串,排除不存在的键不报错。
  • 二者同样是浅层对象类型操作。

原理流程

  1. Pick:遍历保留键并复制值类型。
  2. Omit:先用 Exclude 从键联合中排除 K,再 Pick 剩余键。
  3. 生成新对象类型。

代码 / 示例

type Preview = Pick<User, "id" | "name">;
type Update = Omit<User, "id">;

// Omit 实现等价于:
type OmitImpl<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;

常见误区

  • 误区:Omit 会深拷贝嵌套对象类型;正解:只处理顶层键,嵌套结构原样保留。
  • 误区:Pick 选择不存在的键会静默忽略;正解:Pick 的 K 受 keyof T 约束,非法键直接报错。

追问

  • Q:Omit 与 Exclude 作用对象有何不同? A:Omit 作用于对象键,Exclude 作用于联合成员。
  • Q:如何 Omit 多个类型的公共键? A:分别对每个类型 Omit 后再交叉组合。

03.3.1.4-003 Record<K, V> 与 Readonly<T> 做什么?

一句话结论

Record<K, V> 构造键为 K、值为 V 的字典类型;Readonly<T> 把所有属性标记为只读,防止赋值修改。

概念解释

  • Record 的 K 通常是字符串/数字/符号键联合。
  • Readonly 通过映射加 readonly 修饰符。
  • 只读约束只在编译期生效,运行时对象仍可被修改。

原理流程

  1. Record:键类型映射为字典值类型。
  2. Readonly:遍历属性加只读修饰。
  3. 返回新对象类型。

代码 / 示例

type RoleMap = Record<"admin" | "guest", string[]>;
const roles: RoleMap = { admin: ["read"], guest: ["read"] };

type Frozen = Readonly<User>;
// Frozen.name = "x"; // 编译报错

常见误区

  • 误区:Readonly 会在运行时冻结对象;正解:它只加类型约束,运行时冻结需 Object.freeze。
  • 误区:Record 值类型可以是任意类型而不检查键;正解:键必须匹配 K 联合。

追问

  • Q:Record 与普通对象类型如何选择? A:键集合固定且已知用对象接口,键为动态字符串集合用 Record。
  • Q:只读数组与 Readonly 对象有区别吗? A:只读数组用 readonly T[],Readonly 作用于对象属性。

03.3.1.4-004 Exclude、Extract、NonNullable 如何过滤联合?

一句话结论

Exclude<T, U> 从联合 T 中排除可赋值给 U 的成员;Extract 保留可赋值给 U 的成员;NonNullable 排除 null 与 undefined。

概念解释

  • 三者都依赖条件类型对联合逐个分发。
  • Exclude/Extract 操作联合成员,不操作对象键。
  • NonNullable 是 Exclude 的特化形式。

原理流程

  1. 联合成员逐个进入条件类型。
  2. 按是否可赋值给 U 保留或排除。
  3. 剩余成员组成结果联合。

代码 / 示例

type T = "a" | "b" | 1 | 2;
type R1 = Exclude<T, string>;        // 1 | 2
type R2 = Extract<T, string>;        // "a" | "b"
type R3 = NonNullable<string | null | undefined>; // string

常见误区

  • 误区:Exclude 作用于对象属性;正解:它只过滤联合类型成员,对象键排除用 Omit。
  • 误区:NonNullable 会把空字符串排除;正解:只排除 null 与 undefined。

追问

  • Q:Exclude 与 Omit 内部关系? A:Omit 用 Exclude 过滤键联合后再 Pick。
  • Q:分发被关闭时 Exclude 行为如何? A:整体判断,联合不再逐个过滤,需注意参数是否被包裹。

03.3.1.4-005 ReturnType、Parameters、InstanceType 如何提取签名?

一句话结论

ReturnType<F> 提取函数返回值类型;Parameters<F> 提取参数元组;InstanceType<C> 从构造器类型提取实例类型,底层都是 infer 条件类型。

概念解释

  • 输入类型必须是函数或构造器形态,否则落入 never。
  • 参数元组按位置保留可选与 rest 信息。
  • 这些工具常用于封装通用 Hook、工厂与高阶函数。

原理流程

  1. 约束输入为函数/构造器签名。
  2. infer 占位返回值、参数或实例。
  3. 提取片段作为结果类型。

代码 / 示例

function login(name: string, age: number): Token { /* */ }

type P = Parameters<typeof login>; // [string, number]
type R = ReturnType<typeof login>; // Token

class Box { value = 0 }
type I = InstanceType<typeof Box>; // Box

常见误区

  • 误区:Parameters 返回数组而非元组;正解:它是固定位置的元组类型。
  • 误区:InstanceType 接收普通对象;正解:输入必须是构造器类型(带 new 的类类型)。

追问

  • Q:ConstructorParameters 提取什么? A:构造函数参数元组,与 Parameters 对应构造器版本。
  • Q:提取不到签名时结果是什么? A:落入假分支返回 never。

03.3.1.4-006 Awaited<T> 如何解包 Promise 类型?

一句话结论

Awaited<T> 递归解包 Promise 链,取出最终解析值类型;嵌套 Promise、Promise 联合与非 Promise 值都能处理,是 async 返回类型推导的常用工具。

概念解释

  • 对 Promise<X> 继续解包 X,直到非 Promise。
  • 联合成员分别解包后再合并。
  • 非 Promise 类型原样返回。

原理流程

  1. 判断 T 是否为 PromiseLike 形态。
  2. 是则继续 infer 内部值并递归 Awaited。
  3. 非 Promise 直接返回 T。

代码 / 示例

type P = Promise<Promise<User>>;
type R = Awaited<P>; // User

type Mixed = Awaited<number | Promise<string>>; // number | string

常见误区

  • 误区:Awaited 只解一层 Promise;正解:它递归解包嵌套 Promise。
  • 误区:Awaited 会在运行时等待 Promise;正解:纯类型工具,不产生运行时行为。

追问

  • Q:Awaited 与手写条件类型解包区别? A:内置版本处理了联合、递归与非 Promise 边界,更稳健。
  • Q:async 函数返回类型为什么常是 Promise? A:async 函数始终包装为 Promise,最终值类型用 Awaited 取出。

03.3.1.4-007 内置工具类型为什么是浅层的?

一句话结论

内置 Partial/Readonly/Pick 等只遍历顶层属性,嵌套对象与数组内部结构原样保留;需要贯穿嵌套时必须自己写递归映射类型。

概念解释

  • 内置工具按单层对象映射设计,避免递归带来的复杂度与性能开销。
  • 嵌套字段的可选/只读状态不会随顶层一起改变。
  • 数组元素类型需单独判断处理。

原理流程

  1. 遍历顶层键。
  2. 值类型直接复制或做单层转换。
  3. 嵌套引用类型不再继续展开。

代码 / 示例

interface Nested { a: { b: number } }
type P = Partial<Nested>;
// P.a 可选,但 P.a.b 仍是必填 number

常见误区

  • 误区:Partial 后嵌套对象字段都可不传;正解:只有顶层 a 可选,传了 a 就必须含 b。
  • 误区:Readonly 会让嵌套对象也不可变;正解:嵌套对象引用可变,内部属性未加只读。

追问

  • Q:浅层工具类型的好处? A:实现简单、类型实例化快,符合大多数 API 边界场景。
  • Q:什么时候必须写深层版本? A:配置对象、表单模型等需要逐层可选/只读的场景。

03.3.1.4-008 如何手写深层 DeepPartial 与 DeepReadonly?

一句话结论

在映射类型中判断值是否为对象/数组,是则递归套用自身,否则返回原值;基准分支处理原始值与不可再拆类型。

概念解释

  • 递归需区分普通对象、数组与原始值。
  • 数组要映射元素类型而非按对象键遍历。
  • 循环引用类型可能导致实例化深度问题,需谨慎。

原理流程

  1. 判断 T 是否为对象类型。
  2. 对象/数组分支递归转换值类型。
  3. 原始值直接返回,形成终止条件。

代码 / 示例

type DeepPartial<T> = T extends Array<infer E>
  ? Array<DeepPartial<E>>
  : T extends object
    ? { [K in keyof T]?: DeepPartial<T[K]> }
    : T;

type DeepReadonly<T> = T extends Array<infer E>
  ? ReadonlyArray<DeepReadonly<E>>
  : T extends object
    ? { readonly [K in keyof T]: DeepReadonly<T[K]> }
    : T;

常见误区

  • 误区:直接对所有值递归即可;正解:数组与对象分支需分开,否则数组会被当作普通对象遍历键。
  • 误区:深层工具类型无性能代价;正解:深嵌套对象会增加类型实例化成本,过深可能触发深度限制。

追问

  • Q:Map/Set 在深层类型中怎么处理? A:需单独判断容器类型并映射其元素/值类型。
  • Q:循环引用类型用 DeepPartial 会怎样? A:可能沿引用循环展开,需评估类型实例化深度,按版本行为确认。

03.3.1.4-009 如何实现 Mutable 去除只读?

一句话结论

映射类型中用 -readonly 移除每个属性的只读修饰,得到可修改版本;与内置 Readonly 方向相反。

概念解释

  • -readonly 显式移除只读。
  • 同样是浅层操作,嵌套只读需递归。
  • 常用于内部可变模型与外部只读视图之间转换。

原理流程

  1. 遍历源类型键。
  2. 用 -readonly 去掉只读修饰。
  3. 值类型原样复制。

代码 / 示例

type Mutable<T> = { -readonly [K in keyof T]: T[K] };

interface Config { readonly host: string; readonly port: number }
type Cfg = Mutable<Config>;
// Cfg.host 可重新赋值

常见误区

  • 误区:去掉 readonly 直接写普通属性即可;正解:必须用 -readonly 显式移除,普通映射不会自动去只读。
  • 误区:Mutable 会转换嵌套只读;正解:浅层 Mutable 不处理嵌套。

追问

  • Q:Mutable 与 Readonly 是互逆操作吗? A:单层语义上互逆,深层需递归版本配合。
  • Q:内部模型可变、对外只读如何建模? A:对外暴露 Readonly 视图,内部维护 Mutable 版本。

03.3.1.4-010 类型守卫在类型系统中处于什么位置?

一句话结论

类型守卫是运行时判断与编译期收窄之间的桥梁:守卫函数带 x is T 谓词,断言函数带 asserts x is T,让编译器在分支中缩小类型。

概念解释

  • 守卫返回布尔,供 if/分支使用。
  • 断言函数不返回值,校验失败抛错,通过后收窄类型。
  • 守卫与工具类型配合,把 unknown/联合收窄到具体结构。

原理流程

  1. 写判断逻辑检查值结构。
  2. 返回类型标注谓词 x is T 或 asserts x is T。
  3. 编译器在调用处按谓词收窄类型。

代码 / 示例

function isUser(x: unknown): x is User {
  return typeof x === "object" && x !== null && "id" in x;
}

function assertUser(x: unknown): asserts x is User {
  if (!isUser(x)) throw new Error("invalid user");
}

常见误区

  • 误区:普通返回布尔的函数能让编译器收窄;正解:必须带类型谓词才会触发收窄。
  • 误区:守卫谓词可以随便写而不校验结构;正解:谓词声称的类型应与运行时判断一致,否则类型与运行时脱节。

追问

  • Q:守卫与 as 断言如何选择? A:有运行时判断条件用守卫,纯信任场景才用断言。
  • Q:守卫收窄结果能跨异步回调保留吗? A:不能自动保留,需把收窄后的值存入常量再传入回调。

03.3.1.4-011 类型断言如何与泛型、条件类型配合使用?

一句话结论

断言用于在编译器信息不足时明确类型立场;配合泛型可把约束类型断言为更具体的实参类型,配合条件类型可把推断结果断言为分支类型,但都需先经 unknown 中转不兼容类型。

概念解释

  • 断言不产生运行时检查。
  • 泛型函数内部常需把 T 断言为目标类型。
  • 不兼容类型间直接断言报错,需 as unknown as T。

原理流程

  1. 编译器推断结果过宽或不足。
  2. 用断言指定目标类型。
  3. 运行时仍需守卫或校验兜底。

代码 / 示例

function get<T>(obj: Record<string, unknown>, key: string): T {
  return obj[key] as T;
}

const value = someValue as unknown as User;

常见误区

  • 误区:断言能消除类型错误并保证安全;正解:它只是压下编译提示,错误推迟到运行时。
  • 误区:任意两类型可直接 as 转换;正解:不兼容类型必须经 unknown 中转。

追问

  • Q:断言与类型守卫谁更可靠? A:守卫有运行时校验更可靠,断言仅编译期立场。
  • Q:泛型内部断言为 T 的子类型可行吗? A:需断言为 T 约束范围内类型,否则同样要经 unknown 中转。

03.3.1.4-012 如何对联合类型做批量过滤与映射?

一句话结论

裸类型参数在条件类型中自动分发:过滤用 Exclude/Extract 思路,映射用条件类型把每个成员转为新类型,结果再组成联合。

概念解释

  • 分发保证每个成员独立处理。
  • 想整体判断需包裹参数关闭分发。
  • 联合映射常配合模板字面量生成派生字面量联合。

原理流程

  1. 类型参数接收联合。
  2. 条件类型逐成员判断与转换。
  3. 结果联合合并输出。

代码 / 示例

type ToEvent<T> = T extends string ? `on${Capitalize<T>}` : never;
type Events = ToEvent<"click" | "hover" | 1>;
// "onClick" | "onHover"(数字成员被排除)

常见误区

  • 误区:条件类型对联合整体判断一次;正解:裸参数位置自动逐个分发。
  • 误区:过滤掉的成员仍出现在结果里;正解:排除分支返回 never,合并时被消除。

追问

  • Q:如何保留成员原始类型同时加派生类型? A:结果用联合把原类型与派生类型并列。
  • Q:关闭分发后联合映射结果是什么形态? A:整体作为一个类型进入条件,不再逐成员展开。

03.3.1.4-013 函数签名相关工具类型有哪些?

一句话结论

ThisParameterType<F> 提取函数的 this 类型,OmitThisParameter<F> 移除 this 参数;二者用于封装丢失/恢复 this 绑定的高阶函数。

概念解释

  • 函数首个伪参数 this: T 可被工具提取。
  • 移除 this 参数后得到不绑定 this 的函数类型。
  • 配合 strictFunctionTypes 与 noImplicitThis 使用。

原理流程

  1. 约束输入为函数签名。
  2. infer 提取 this 类型或移除该伪参数。
  3. 返回处理后的函数类型。

代码 / 示例

type Handler = (this: App, event: string) => void;
type This = ThisParameterType<Handler>; // App
type Plain = OmitThisParameter<Handler>; // (event: string) => void

常见误区

  • 误区:this 参数是普通参数会出现在元组里;正解:它是伪参数,不进入 Parameters 结果。
  • 误区:OmitThisParameter 会在运行时解绑 this;正解:只改变类型,运行时绑定仍需 bind/call。

追问

  • Q:如何标注函数的 this 类型? A:在参数列表首位写 this: T,不占用实参位置。
  • Q:无 this 标注时 ThisParameterType 返回什么? A:返回 unknown。

03.3.1.4-014 数组与字符串有哪些常用内置类型工具?

一句话结论

数组相关靠 infer E[] 提取元素类型;字符串相关靠四个大小写操作类型与模板字面量;数字类型没有专用内置转换工具,通常作为字面量联合参与拼接。

概念解释

  • 元素类型提取:T extends (infer E)[] ? E : never。
  • 字符串操作:Uppercase/Lowercase/Capitalize/Uncapitalize。
  • 数字字面量在模板中转为字符串形式,细节按版本确认。

原理流程

  1. 判断来源是否为数组/字符串字面量。
  2. infer 或内置工具提取/转换片段。
  3. 返回元素类型或派生字符串联合。

代码 / 示例

type ElementOf<T> = T extends (infer E)[] ? E : never;
type El = ElementOf<number[]>; // number

type Greeting = `Hello ${Capitalize<"world">}`; // "Hello World"

常见误区

  • 误区:内置工具能把数字类型转字符串字面量;正解:模板拼接可转换,专用数字字符串工具需按版本确认是否存在。
  • 误区:字符串工具作用于任意字符串值;正解:只作用于类型层面的字面量类型。

追问

  • Q:元组长度类型怎么取? A:T['length'] 索引访问元组类型。
  • Q:数组元素是联合时提取结果是什么? A:元素类型联合本身。

03.3.1.4-015 如何从对象类型派生事件回调属性类型?

一句话结论

用模板字面量生成 onXxx 属性名,映射值类型为对应事件处理器;键重映射把原键转为派生键,值位置引用原属性或定义回调签名。

概念解释

  • 派生键名靠模板字面量与 Capitalize。
  • 值类型需定义事件名到处理器签名的映射表。
  • 常用于组件 props、事件总线类型建模。

原理流程

  1. 定义事件名到载荷类型的映射。
  2. 键重映射生成 on + 大写事件名。
  3. 值类型写为接收对应载荷的处理器函数。

代码 / 示例

type Events = { click: MouseEvent; hover: PointerEvent };

type EventHandlers = {
  [K in keyof Events as `on${Capitalize<string & K>}`]:
    (payload: Events[K]) => void;
};
// { onClick: (p: MouseEvent) => void; onHover: (p: PointerEvent) => void }

常见误区

  • 误区:派生属性会自动绑定运行时监听;正解:类型只描述 props 形状,事件绑定需运行时实现。
  • 误区:键为非字符串时 Capitalize 可直接用;正解:先用 string & K 收窄键类型。

追问

  • Q:事件载荷为可选时类型如何表达? A:处理器参数类型加 | undefined 或载荷字段标可选。
  • Q:如何支持通配事件监听? A:额外加一个索引签名类型覆盖任意事件名。

03.3.1.4-016 类型编程中 never 如何参与过滤?

一句话结论

条件分支返回 never 表示该成员被排除;联合合并时 never 被自动消除,映射重映射返回 never 的键不进入结果对象,是过滤的标准手段。

概念解释

  • never 是底层类型,不包含任何值。
  • A | never 等价于 A。
  • 过滤联合成员与对象键都靠返回 never 实现。

原理流程

  1. 条件判断目标成员是否保留。
  2. 排除分支返回 never。
  3. 合并阶段消除 never,得到剩余类型。

代码 / 示例

type OnlyNumbers<T> = T extends number ? T : never;
type R = OnlyNumbers<1 | "a" | 2>; // 1 | 2

type WithoutId<T> = {
  [K in keyof T as K extends "id" ? never : K]: T[K];
};

常见误区

  • 误区:过滤应返回 undefined;正解:对象键过滤与联合排除都使用 never。
  • 误区:never 会显式出现在最终类型里;正解:联合中的 never 被编译器自动消除。

追问

  • Q:为什么 Exclude 假分支写 never? A:排除成员不进入结果,never 合并时被丢弃。
  • Q:返回 never 的属性在赋值时会怎样? A:该键不允许传入,属于被过滤状态。

03.3.1.4-017 手写 MyPick 与 MyReadonly 考察什么?

一句话结论

手写工具类型考察映射类型、keyof、索引访问与修饰符:MyPick 遍历保留键复制值类型,MyReadonly 遍历加只读修饰,是理解内置工具实现的基础练习。

概念解释

  • MyPick:约束 K 为 keyof T 子集,映射保留键。
  • MyReadonly:遍历所有键加 readonly。
  • 实现需正确使用索引访问 T[K] 取值类型。

原理流程

  1. 声明类型参数 T 与 K。
  2. 映射遍历 K 或 keyof T。
  3. 值位置复制 T[K],按需加修饰符。

代码 / 示例

type MyPick<T, K extends keyof T> = {
  [P in K]: T[P];
};

type MyReadonly<T> = {
  readonly [K in keyof T]: T[K];
};

常见误区

  • 误区:MyPick 值类型写成 T;正解:应取 T[P] 对应键的值类型。
  • 误区:MyReadonly 需要 -readonly 移除后再加;正解:直接在属性前加 readonly 即可。

追问

  • Q:MyOmit 怎么在 MyPick 基础上实现? A:先 Exclude 键联合,再 Pick 剩余键。
  • Q:映射类型键名必须与源键一致吗? A:默认一致,需要派生键名时用 as 重映射。

03.3.1.4-018 工具类型与类型体操的使用边界是什么?

一句话结论

优先复用内置工具类型,业务代码保持类型直观可读;只有在封装通用库、建模复杂接口签名或消除重复类型标注时才写自定义体操,复杂类型必须用样例验证。

概念解释

  • 内置工具覆盖大部分对象/联合/函数操作场景。
  • 过度体操导致类型难以阅读、报错信息难以定位。
  • 类型是开发期契约,不应替代运行时校验。

原理流程

  1. 判断需求能否用内置工具组合完成。
  2. 不行再写自定义映射/条件类型。
  3. 用正反样例在编辑器验证展开结果与报错提示。

代码 / 示例

// 优先组合内置工具
type SafeUpdate = Partial<Omit<User, "id" | "createdAt">>;

// 仅在通用封装处写自定义递归类型
type DeepReadonly<T> = /* 见 03.3.1.4-008 */ T;

常见误区

  • 误区:类型体操写得越复杂越能体现水平;正解:可维护性优先,简单清晰的普通类型更好。
  • 误区:类型覆盖了就不需要运行时校验;正解:编译期类型不拦截非法运行时值,边界处仍需校验。

追问

  • Q:团队内复杂类型如何维护? A:抽为独立类型文件、补充注释与样例类型,避免散落在业务组件中。
  • Q:类型报错信息看不懂时怎么排查? A:把复杂类型逐步拆解为中间类型,用编辑器悬停查看每步展开结果。