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

03.3.1.3 条件、映射与模板字面量类型

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

03.3.1.3-001 条件类型的基本形态是什么?

一句话结论

条件类型写成 T extends U ? X : Y,在类型层面做“如果 T 可赋值给 U 则取 X,否则取 Y”的分支判断,是类型编程的核心分支手段。

概念解释

  • 条件类型只在编译期求值,不产生运行时代码。
  • 泛型位置上的条件类型会延迟到实参确定后再解析。
  • 可嵌套组合形成复杂类型推导。

原理流程

  1. 判断来源类型是否满足约束类型。
  2. 满足取真分支类型,否则取假分支。
  3. 结果作为新类型返回给上层使用。

代码 / 示例

type IsString<T> = T extends string ? true : false;

type A = IsString<"hi">; // true
type B = IsString<42>;   // false

常见误区

  • 误区:条件类型会在运行时判断值;正解:它是纯类型层面分支,产物中不存在。
  • 误区:extends 在这里表示类继承;正解:此处表示类型可赋值性判断。

追问

  • Q:条件类型延迟解析是什么意思? A:泛型未确定实参时保留为条件类型,传入具体类型后才展开结果。
  • Q:条件类型能嵌套吗? A:可以,假/真分支继续写条件类型形成层级判断。

03.3.1.3-002 什么是分布式条件类型?

一句话结论

当裸类型参数 T 出现在条件类型中,且 T 是联合类型时,编译器会把联合拆开逐个判断,结果再组成联合;这就是分布式条件类型。

概念解释

  • 分发只发生在裸类型参数位置。
  • 联合成员各自经过条件类型处理。
  • 想整体判断需把参数包裹进元组或数组。

原理流程

  1. 检查条件类型中被判断的是否为裸类型参数。
  2. 是裸参数且为联合,则逐成员分发。
  3. 各成员结果合并为最终联合类型。

代码 / 示例

type ToArray<T> = T extends any ? T[] : never;

type R = ToArray<string | number>;
// string[] | number[](逐个分发)

type ToArrayNonDist<T> = [T] extends [any] ? T[] : never;
type R2 = ToArrayNonDist<string | number>;
// (string | number)[](整体判断)

常见误区

  • 误区:所有条件类型都自动分发;正解:只有裸类型参数位置才触发分发。
  • 误区:分发结果总是数组;正解:分发只改变判断方式,结果类型由分支决定。

追问

  • Q:如何关闭分发? A:用 [T] extends [U] 把参数包进元组。
  • Q:分发在过滤类型时起什么作用? A:配合 Exclude 逐个成员排除,得到剩余联合。

03.3.1.3-003 infer 如何提取类型中的片段?

一句话结论

infer R 在条件类型的约束位置声明一个待推断类型变量,把匹配到的结构片段提取出来,常用于提取函数返回值、参数、数组元素与字符串片段。

概念解释

  • infer 只能出现在 extends 右侧的条件类型中。
  • 提取出的类型变量在真分支使用。
  • 同一结构可声明多个 infer 分别提取不同位置。

原理流程

  1. 在约束模式中用 infer 占位待提取位置。
  2. 编译器匹配来源类型结构。
  3. 把匹配片段绑定到 infer 变量,在分支中使用。

代码 / 示例

type ReturnType<T> = T extends (...args: any[]) => infer R ? R : never;
type FirstArg<T> = T extends (a: infer A, ...rest: any[]) => any ? A : never;
type ElementType<T> = T extends (infer E)[] ? E : never;

type R = ReturnType<() => User>; // User
type E = ElementType<number[]>; // number

常见误区

  • 误区:infer 可以出现在类型别名任意位置;正解:只能在条件类型的 extends 模式中。
  • 误区:infer 提取的是运行时值;正解:提取的是类型片段,运行时不存在。

追问

  • Q:函数参数如何逐个提取为元组? A:用 (...args: infer P) => any 得到参数元组类型。
  • Q:数组元素提取不到时返回什么? A:落入假分支,通常为 never。

03.3.1.3-004 映射类型的基本形态是什么?

一句话结论

映射类型写成 { [K in keyof T]: NewType },遍历对象类型 T 的每个键,把值类型批量转换为新类型,是批量改造对象类型的手段。

概念解释

  • in 遍历键联合,K 依次绑定每个键。
  • 值类型位置可引用 T[K] 做转换。
  • 映射结果仍是对象类型,键集合来自源类型。

原理流程

  1. keyof T 得到键联合。
  2. 逐个键映射到新值类型。
  3. 生成包含全部键的新对象类型。

代码 / 示例

type Optional<T> = { [K in keyof T]?: T[K] };
type Readonly<T> = { readonly [K in keyof T]: T[K] };
type Nullable<T> = { [K in keyof T]: T[K] | null };

type UserOpt = Optional<User>;

常见误区

  • 误区:映射类型会修改原类型;正解:它生成新类型,源类型不变。
  • 误区:映射可以新增源类型没有的键;正解:默认键集合来自 keyof T,新增键需另写交叉类型。

追问

  • Q:映射类型与 Partial 是什么关系? A:Partial 就是可选修饰符的映射类型实现。
  • Q:值类型如何在映射时做条件转换? A:值位置写条件类型,按 T[K] 形态选择结果。

03.3.1.3-005 映射类型的 readonly 与可选修饰符怎么增减?

一句话结论

映射时可用 +/- 前缀显式添加或移除 readonly 与 ? 修饰符;不带前缀默认是添加,移除修饰符必须写 -。

概念解释

  • +readonly、+? 为添加修饰符。
  • -readonly、-? 为移除修饰符。
  • 不加符号等价于 +。

原理流程

  1. 遍历源类型键。
  2. 按修饰符前缀决定添加/移除只读或可选。
  3. 生成带目标修饰符的新类型。

代码 / 示例

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

interface Config { readonly host: string; port?: number }
type Cfg = Mutable<Config>;   // host 可变
type Cfg2 = Required<Config>; // port 必填

常见误区

  • 误区:直接写 readonly 能移除只读;正解:移除必须用 -readonly。
  • 误区:? 可以直接去掉可选;正解:移除可选需 -?。

追问

  • Q:Required<T> 与 Partial<T> 修饰符方向相反吗? A:是,Required 去可选,Partial 加可选。
  • Q:修饰符能同时作用于键和值吗? A:readonly 作用于属性,? 作用于可选性,二者独立。

03.3.1.3-006 键重映射 as 能做什么?

一句话结论

映射类型中用 as NewKey 把原键重命名为新键,可配合模板字面量生成派生键名,也可在重映射中过滤掉不需要的键。

概念解释

  • 重映射表达式返回新的键类型。
  • 返回 never 的键会被排除。
  • 新键名常由模板字面量拼接原键得到。

原理流程

  1. 遍历 keyof T。
  2. as 表达式计算新键或返回 never 过滤。
  3. 生成重命名/过滤后的对象类型。

代码 / 示例

type Getters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K];
};

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

常见误区

  • 误区:重映射可以改变值类型而不改键;正解:值类型在冒号后写,键名在 as 后写,二者独立。
  • 误区:过滤键返回 undefined;正解:重映射过滤需返回 never。

追问

  • Q:Capitalize 作用于非字符串键怎么办? A:先用 string & K 收窄到字符串键,避免类型错误。
  • Q:重映射后原键还保留吗? A:不保留,as 后的新键替换原键。

03.3.1.3-007 模板字面量类型如何拼接字符串类型?

一句话结论

模板字面量类型 `prefix-${T}` 把联合类型成员拼进字符串位置,生成新的字符串字面量联合,用于建模事件名、路径名、属性派生名。

概念解释

  • 字符串位置可插入类型参数或键联合。
  • 插入联合时按成员逐个分发拼接。
  • 结果仍是字面量联合,可用于约束取值范围。

原理流程

  1. 写模板字面量并在 ${} 中放类型。
  2. 联合成员逐个参与拼接。
  3. 得到派生字符串字面量联合。

代码 / 示例

type EventName<T extends string> = `on${Capitalize<T>}`;
type R = EventName<"click" | "hover">;
// "onClick" | "onHover"

type Route<T extends string> = `/api/${T}`;

常见误区

  • 误区:模板字面量类型会生成运行时字符串;正解:它只约束类型,运行时字符串需手写或拼接代码生成。
  • 误区:插入数字联合也按字符串拼接;正解:数字字面量会被转为对应字符串形式,细节按版本行为确认。

追问

  • Q:模板字面量能用于事件回调类型映射吗? A:可以,配合键重映射生成 onClick: Handler 一类派生属性。
  • Q:联合在模板中如何分发? A:与条件类型分发一致,逐个成员拼接后再合并联合。

03.3.1.3-008 内置字符串操作类型有哪些?

一句话结论

TS 提供 Uppercase、Lowercase、Capitalize、Uncapitalize 四个内置字符串操作类型,在类型层面转换字符串字面量大小写。

概念解释

  • Uppercase/Lowercase 整体大小写转换。
  • Capitalize 首字母大写,Uncapitalize 首字母小写。
  • 只作用于字符串字面量类型,非字符串需先收窄。

原理流程

  1. 传入字符串字面量联合。
  2. 内置类型按规则转换每个成员。
  3. 返回转换后的字面量联合。

代码 / 示例

type A = Capitalize<"click">;      // "Click"
type B = Uppercase<"hover">;       // "HOVER"
type C = Uncapitalize<"Click">;    // "click"
type D = Lowercase<"OK">;          // "ok"

常见误区

  • 误区:这些类型在运行时转换字符串;正解:编译后擦除,运行时需用 toUpperCase() 等方法。
  • 误区:可作用于任意类型;正解:输入需为字符串字面量,否则结果行为不确定,需收窄。

追问

  • Q:首字母大写后拼接 getter 名怎么做? A:`get${Capitalize<K>}` 配合键重映射。
  • Q:内置字符串类型版本支持范围? A:属 TS 版本相关能力,需对照所用版本文档确认。

03.3.1.3-009 如何用 infer 在模板字面量中提取前缀与后缀?

一句话结论

在模板字面量模式中用 infer 占位前后片段,可把字符串字面量拆成前缀、后缀或参数段,实现类型层面的路径解析与参数提取。

概念解释

  • 模式两侧写固定字面量,中间用 infer 占位。
  • 匹配成功后片段绑定到 infer 变量。
  • 可多层嵌套提取嵌套路径。

原理流程

  1. 写 `prefix-${infer Rest}` 形式的模式。
  2. 来源字符串匹配固定部分。
  3. 剩余片段类型在真分支使用。

代码 / 示例

type BeforeDash<S extends string> =
  S extends `${infer P}-${string}` ? P : S;

type Param<S extends string> =
  S extends `/users/${infer Id}` ? Id : never;

type R = BeforeDash<"order-created">; // "order"
type U = Param<"/users/42">;         // "42"

常见误区

  • 误区:infer 能提取运行时路径参数;正解:只在类型层面匹配,路由参数解析仍需运行时代码。
  • 误区:多个 infer 可跨片段任意组合;正解:按模板位置顺序绑定,错位匹配会落入假分支。

追问

  • Q:提取嵌套路径怎么写? A:在 infer 片段上继续套条件类型递归拆分。
  • Q:匹配不到时返回什么? A:假分支,通常给 never 或原字符串。

03.3.1.3-010 条件类型如何做递归展开?

一句话结论

条件类型可在分支中引用自身,对嵌套对象、元组或字符串逐层拆解,直到命中基准分支,实现深度转换与递归提取。

概念解释

  • 递归类型需有终止条件,否则类型层面无法收敛。
  • 常用于深层 Partial、深层只读、递归元组处理。
  • 过深递归可能触发 TS 类型实例化深度限制,细节按版本配置确认。

原理流程

  1. 写基准分支处理不可再拆的类型。
  2. 复合类型分支递归调用自身。
  3. 逐层展开直到全部命中基准分支。

代码 / 示例

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

type Nested = { a: { b: number } };
type P = DeepPartial<Nested>;
// { a?: { b?: number } }

常见误区

  • 误区:递归类型没有终止条件也能收敛;正解:缺少基准分支会沿类型结构无限展开。
  • 误区:深层转换只对一层生效;正解:递归类型可贯穿嵌套对象与数组。

追问

  • Q:数组在 DeepPartial 中如何处理? A:需单独判断数组类型并映射元素类型,否则会按普通对象处理。
  • Q:类型递归深度超限怎么排查? A:检查是否存在循环引用类型与过深嵌套,对照 TS 实例化深度配置确认。

03.3.1.3-011 条件类型中 never 与 unknown 扮演什么角色?

一句话结论

never 用于条件分支中表示“排除/不可能”,unknown 作为兜底顶层类型;联合分发时 never 成员会被自然消除,unknown 作为未收窄的安全兜底。

概念解释

  • 条件假分支常返回 never 表示该成员不合法。
  • 无法确定具体类型时兜底为 unknown,使用前需收窄。
  • 分发结果中的 never 不影响最终联合。

原理流程

  1. 分支判断后合法类型进入结果。
  2. 不合法分支返回 never。
  3. 联合合并时 never 被忽略,剩余成员组成结果。

代码 / 示例

type FilterString<T> = T extends string ? T : never;
type R = FilterString<"a" | 1 | true>; // "a"

type Fallback<T> = T extends unknown ? T : never;

常见误区

  • 误区:never 会出现在最终联合里;正解:联合中的 never 被自动消除。
  • 误区:unknown 分支等于不做检查;正解:unknown 仍强制使用前收窄,比 any 安全。

追问

  • Q:T extends unknown 总是成立吗? A:是,unknown 是顶层类型,所有类型都可赋值给它。
  • Q:条件类型如何把对象字段排除为 never? A:在映射重映射中按条件返回 never 过滤键。

03.3.1.3-012 映射类型如何组合条件类型转换值?

一句话结论

值类型位置写条件类型,可按源属性的类型形态分别转换:函数转方法、可选字段保留可选、原始值包裹成可空类型。

概念解释

  • 映射遍历键,值位置引用 T[K]。
  • 条件类型按值类型选择目标形态。
  • 可同时转换键名与值类型。

原理流程

  1. 遍历 keyof T。
  2. 值位置条件判断 T[K]。
  3. 生成转换后的对象类型。

代码 / 示例

type WrapPrimitive<T> = {
  [K in keyof T]: T[K] extends object ? T[K] : T[K] | null;
};

type AsMethods<T> = {
  [K in keyof T]: () => T[K];
};

常见误区

  • 误区:条件判断作用于键而非值;正解:T[K] extends ... 判断的是值类型。
  • 误区:转换值类型会自动去掉原可选性;正解:可选修饰符需单独用 ?/-? 处理。

追问

  • Q:如何区分函数属性与普通对象属性? A:判断 T[K] extends (...args: any[]) => any。
  • Q:条件值类型能保留源字段修饰符吗? A:可以,映射默认继承 ? 与 readonly,需显式增减。

03.3.1.3-013 如何在类型层面过滤对象的键?

一句话结论

在映射重映射中按键名或值类型条件返回 never 排除目标键,其余键保留;等价于手工实现 Omit、Pick 的变体。

概念解释

  • 按键名过滤用 K extends 排除集合 ? never : K。
  • 按值类型过滤用 T[K] extends 目标类型 ? K : never。
  • 返回 never 的键不进入结果对象。

原理流程

  1. 遍历源类型键。
  2. 重映射表达式判断保留或排除。
  3. 生成过滤后的对象类型。

代码 / 示例

type OmitKeys<T, K extends keyof any> = {
  [P in keyof T as P extends K ? never : P]: T[P];
};

type PickFunctionKeys<T> = {
  [K in keyof T as T[K] extends (...args: any[]) => any ? K : never]: T[K];
};

常见误区

  • 误区:过滤键返回 undefined;正解:重映射排除必须返回 never。
  • 误区:按值类型过滤后键类型自动转换;正解:值类型仍由冒号后表达式决定。

追问

  • Q:Omit<T, K> 内部怎么实现? A:Pick<T, Exclude<keyof T, K>>。
  • Q:过滤联合成员与过滤对象键是同一套机制吗? A:前者靠条件分发,后者靠映射重映射,思路相通。

03.3.1.3-014 infer 如何提取函数返回值与参数元组?

一句话结论

用 (...args: infer P) => infer R 一次提取参数元组 P 与返回值 R,是内置 Parameters、ReturnType 的实现原理。

概念解释

  • 参数位置 infer 得到元组类型。
  • 返回位置 infer 得到返回值类型。
  • 约束需匹配函数形态,否则落入假分支。

原理流程

  1. 写函数签名模式,参数与返回值用 infer 占位。
  2. 匹配来源函数类型。
  3. 取出 P 与 R 在分支使用。

代码 / 示例

type ParamsOf<T> = T extends (...args: infer P) => any ? P : never;
type ReturnOf<T> = T extends (...args: any[]) => infer R ? R : never;

function send(name: string, count: number) {}
type P = ParamsOf<typeof send>; // [string, number]
type R = ReturnOf<typeof send>; // void

常见误区

  • 误区:参数 infer 得到数组类型;正解:函数 rest 参数推断为元组类型,固定各位置类型。
  • 误区:方法与普通函数签名提取方式不同;正解:结构匹配即可,写法一致。

追问

  • Q:提取构造器实例类型怎么做? A:T extends new (...args: any[]) => infer I ? I : never。
  • Q:可选参数在元组中如何体现? A:元组对应位置类型带 undefined 并标记可选。

03.3.1.3-015 条件类型在协变位置推断有什么注意点?

一句话结论

infer 在返回值、属性等协变位置提取类型;在参数等逆变位置提取出的类型方向与直觉相反,直接使用可能得到过宽或过窄的结果。

概念解释

  • 协变位置:来源类型是子类型时提取结果更具体。
  • 逆变位置:参数类型方向相反,提取需谨慎。
  • 复杂函数类型提取建议对照内置工具类型行为验证。

原理流程

  1. 定位 infer 所处位置。
  2. 按位置协变/逆变方向理解提取结果。
  3. 不确定时用具体类型样例推演结果。

代码 / 示例

type ReturnInfer<T> = T extends () => infer R ? R : never;
// R 处于协变位置,按返回类型提取

常见误区

  • 误区:所有 infer 位置提取结果方向一致;正解:参数位置为逆变,方向不同。
  • 误区:提取结果可以直接当作输入类型使用;正解:逆变位置提取出的类型需结合兼容方向再判断。

追问

  • Q:如何验证推断结果是否符合预期? A:写具体样例类型,用编辑器悬停查看展开后的类型。
  • Q:逆变相关规则版本间有差异吗? A:函数参数严格度随 strictFunctionTypes 与版本演进,需实测确认。

03.3.1.3-016 能否用条件类型判断两个类型严格相等?

一句话结论

通用“类型相等判断”在纯条件类型中难以可靠实现:可赋值性判断是双向包含,但 TS 不暴露直接的类型恒等操作;常见技巧基于函数参数的逆变位置比较,属高级类型体操,结果需用样例验证。

概念解释

  • A extends B 只检查单向可赋值性。
  • 双向 extends 也不等同于严格恒等(结构类型系统中同名不同源类型结构一致即兼容)。
  • 实战中更应依赖结构兼容,而非强行做名义相等判断。

原理流程

  1. 单向 extends 检查方向包含关系。
  2. 双向检查尝试模拟互包含。
  3. 遇到函数、联合、可选属性时边界复杂,需样例验证。

代码 / 示例

// 演示用:基于函数参数逆变的常见相等技巧,行为需用样例验证
type IsEqual<A, B> =
  (<T>() => T extends A ? 1 : 2) extends
  (<T>() => T extends B ? 1 : 2) ? true : false;

常见误区

  • 误区:条件类型能直接返回“类型是否相同”;正解:纯类型系统只做可赋值性判断,相等技巧有适用边界。
  • 误区:结构一致的两个类型在 TS 中不兼容;正解:结构类型系统下二者互相兼容,不存在名义上的不等。

追问

  • Q:为什么需要模拟相等? A:类型体操场景下区分裸类型与包装类型,日常业务代码很少需要。
  • Q:不确定相等技巧行为怎么办? A:写正反样例在编辑器验证,属版本相关行为,不编造结论。

03.3.1.3-017 条件与映射类型如何建模 API 的请求响应类型?

一句话结论

按方法名或路径键映射出对应的请求参数与响应类型:键重映射生成方法名,条件/infer 从签名提取参数与返回值,实现类型安全的 API 客户端。

概念解释

  • 先定义每个接口的签名映射表。
  • 用映射类型批量生成调用方法类型。
  • infer 提取参数与返回值透传到客户端方法。

原理流程

  1. 定义接口名到函数签名的映射类型。
  2. 映射生成方法名与方法类型。
  3. 调用处按方法名获得参数与响应类型提示。

代码 / 示例

interface ApiMap {
  "/users": () => User[];
  "/login": (body: { name: string }) => Token;
}

type ApiClient = {
  [K in keyof ApiMap]: ApiMap[K];
};

常见误区

  • 误区:运行时会按类型自动校验请求体;正解:类型只在编译期提示,运行时仍需 schema 校验。
  • 误区:映射生成的方法会自动绑定实现;正解:类型只描述形状,实现函数需另行编写。

追问

  • Q:路径带参数时如何提取参数类型? A:模板字面量 infer 拆分路径段,映射到参数类型。
  • Q:错误响应类型如何表达? A:在签名返回类型中用联合表达成功/失败分支。

03.3.1.3-018 类型体操实战需要掌握哪些判断边界?

一句话结论

实战中先判断是“遍历对象键”(映射)、“按形态分支”(条件)、“提取结构片段”(infer)还是“拼接键名”(模板字面量),再组合使用;遇到递归与逆变位置先写样例验证,不凭空推导。

概念解释

  • 四类手段各司其职,复杂类型由它们组合而成。
  • 内置工具类型是现成组合,优先复用而非重写。
  • 类型过度复杂会损害可读性,业务代码应克制使用体操。

原理流程

  1. 拆解目标类型需要的转换动作。
  2. 选择映射/条件/infer/模板字面量对应手段。
  3. 用正反样例在编辑器验证展开结果。

代码 / 示例

// 组合:过滤键 + 转可选 + 派生 getter
type Draft<T> = Partial<Omit<T, "id">>;
type Getters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K];
};

常见误区

  • 误区:业务代码里类型越复杂越专业;正解:过度体操降低可维护性,清晰的普通类型优先。
  • 误区:可以凭直觉推断复杂条件类型结果;正解:必须用样例在编辑器悬停确认展开类型。

追问

  • Q:常用内置工具类型有哪些? A:Partial/Required/Pick/Omit/Record/Readonly/Exclude/Extract/NonNullable/ReturnType/Parameters/Awaited,见 03.3.1.4。
  • Q:类型体操结果与运行时行为不一致怎么办? A:类型只描述约定,运行时边界需单独校验与测试。