条件类型与映射类型体操

可视化演示

展示TypeScript条件类型的分支推断与映射类型的属性变换流程，揭示类型系统如何实现条件判断与批量属性转换。

条件类型基础：分拣机的第一问

分拣中心的传送带把包裹送到蓝色扫描灯下，机器只问一句话：“这个包裹能塞进标准箱 U 吗？”能，推入 X 通道；不能，滑向 Y 通道。TypeScript 的条件类型就是这台机器——它把“能不能塞进”翻译成“T 是否结构兼容于 U”，一句话问完，两个通道二选一。

条件类型的完整写法是 T extends U ? X : Y。注意这里的 extends 不是类的继承，而是一台“结构兼容扫描仪”：只要 T 拥有 U 要求的全部形状，哪怕 T 还多出几个属性，也算通过。就好比分拣机的标准箱只关心长宽高，包裹里多塞一块泡沫都不影响它能被装进去。这种“问规格”发生在编译期，运行时根本不存在这台扫描灯。

条件类型可以出现在任何类型能出现的地方，比如 type IsString<T> = T extends string ? true : false; 用起来就像给类型世界写 if/else。它常与泛型配合，让类型根据输入的不同自动选择出口，这正是类型体操里最基础的“起手式”。

回到分拣中心：扫描灯“叮”的一声之后，包裹已经消失在某一侧的传送带上。条件类型的妙处也在于此——它不问过程，只问结果，一锤定音地根据输入决定输出，类型自此有了“判断力”。

分布式条件：一箱混装的独立判型

分拣中心偶尔会接到一箱混装的包裹：箱子里同时叠着字符串包裹、数字包裹和布尔包裹。蓝灯扫描仪的规矩是：不判断整箱，而是把箱子拆开，让每个单件独立过一遍扫描灯，最后再把各自的结果重新拼成一箱。这个规矩叫“分布式条件类型”。

对应的语法事实是：当 T 是一个裸的泛型参数，且调用时传入的是联合类型 string | number | boolean 时，T extends U ? X : Y 会自动对每个成员分别求值。比如 T extends string ? 1 : 2，传入 string | number 时，结果是 1 | 2，而不是整个联合被一票否决议成 2。

内置工具类型 Exclude 就是典型的分布式机器：Exclude<T, U> 把 T 中所有能赋给 U 的成员换成 never（相当于在传送带上直接扔掉），剩下的成员自动合并返回。若想关掉“拆箱”，把 T 用方括号包起来写成 [T] extends [U]，就像给整箱包裹加一道封条，扫描仪就只能整箱判断了。

这就像混装箱被拆开、逐件扫描、再重新装箱：每个单件都保有独立判断的权利，谁也不会因为“同箱的兄弟不合格”而被连坐。分布式条件类型让联合类型的处理精确到“每一个成员”，是类型体操里最常用的机关之一。

infer 关键字：拆包裹取说明书

有些包裹里夹着一本说明书，写着“本包裹实际装载的是 X 类型”。分拣中心在扫描灯旁边开了一个检查窗口：窗口上写着“infer R“，意思是”让我看看里面到底装了什么，并把答案记到 R 上”。这个窗口就是 infer 关键字。

infer 只能出现在条件类型的 extends 匹配模式里。最经典的应用是提取函数返回类型：ReturnType<F> 会先检查 F 是否匹配“一个函数”的形态，匹配时在返回位置放一个 infer R 占位符，让 TypeScript 把真实的返回类型填进 R。就像一个窗口把函数签名“摊开”给你看：参数那一段用 ...args: any[] 模糊处理，返回值那一段由 infer 精确抄录。

换个例子：type First<T extends any[]> = T extends [infer F, ...any[]] ? F : never; 可以从元组里提取第一个元素的类型。infer 的位置决定它能提取什么——放在返回类型处取返回值，放在元组头部取首元素，放在 Promise 内部就取被包裹的内层类型。它的作用域仅限于当前条件分支，出了这个分支，R 就作废了。

检查窗口的存在，让“拆包裹”变得合法且有边界：infer 不是魔法，它必须依附于一个具体的模式匹配。就像分拣员只能在指定窗口拆包，换一个位置（比如直接写 type X = infer R）就不被允许。学会在正确的位置安放 infer，类型体操就入门了一半。

映射类型：批量改造货架车间

分拣中心的深处是货架车间。主管发话：“这排货架，每个抽屉都贴一张'可选'标签；那排货架，每个抽屉都加一把锁。”工人不需要逐个抽屉手工处理，而是拿着钥匙串 keyof T，用 in 循环从第一把钥匙走到最后一把，全程机械化操作。这套批量改造流程叫映射类型。

映射类型的写法是 { [K in keyof T]: T[K] }。keyof T 把对象的所有键收集成联合类型，好比把整排货架的钥匙串到一起；K in 像 for 循环一样逐个取出键名；T[K] 则用键去索引原来的类型，取出对应抽屉里的值类型。三者配合，就能“照原样复制”一个对象类型——或者在此基础上做任意改造。

说它是“同态变换”是因为输出类型与输入类型共享同一套键：键没有增减，只是每个键对应的值类型被统一处理。比如 { [K in keyof T]: T[K][] } 会让每个属性都变成数组。货架还是那排货架，抽屉里的东西全被换成了“数组包装”。映射类型管的是“形状”，不改“骨架”。

货架车间的哲学是“批量化、机械化”：只要给出钥匙串和处理规则，整排货架一次改造完成。映射类型因此成为所有内置工具类型的底盘——下一节的修饰符增减，就是在改造指令上多写了几个符号而已。

修饰符增减：贴锁、撕签与重贴铭牌

车间主管的指令不只是“改造值类型”，还能动属性本身的“属性”：加一把锁，叫 readonly；贴一张“可选”标签，叫 ?；反过来，撕掉标签就用减号。TypeScript 给映射类型准备了专门的修饰符语法：+ 表示添加，- 表示移除。

最常见的操作有两个。一是加锁：{ readonly [K in keyof T]: T[K] } 让每个属性都变成只读，编译期禁止再赋值；二是加减可选标记：{ [K in keyof T]-?: T[K] } 把所有可选属性变成必选，这就是内置工具 Required<T> 的实现原理。+? 则反过来把每个属性都变成可选，也就是 Partial<T> 的实现。

更高级的玩法是 as 键重映射：{ [K in keyof T as \get${Capitalize<K>}\]: T[K] } 可以把键名改造成 getXxx 的形式。好比给货架换一套新铭牌，键还是那些键，但名字全变了。修饰符加减配合 as 重映射，让映射类型从“复制”进化成“再创作”。

除了解除可选，还有一套对应的“重贴铭牌”公式：

修饰符就像是货架上的标签系统：readonly 是“请勿擅动”的警示牌，? 是“可缺省”的便利贴，减号是撕下旧标签的手。掌握这些符号的增删，就能像车间主管一样精准控制每个属性的“脾气”。

内置工具类型：标准化改造机器

分拣中心备有一套标准化机器，每台机器背后都是一段我们刚刚学过的映射或条件表达式。Partial<T> 全员可选，Required<T> 全员必选，Readonly<T> 全员加锁——三台机器共用同一个遍历底盘，只是修饰符不同。Record<K, V> 则不一样：它不改造已有对象，而是用 K 这串钥匙凭空造出一排新货架，每个抽屉统一放 V 类型的货物。

Pick<T, K> 是“挑拣机”：从 T 中只保留键集 K 里的属性；Omit<T, K> 反过来，剔除 K 里的属性。Exclude<T, U> 和 Extract<T, U> 是条件类型家族的成员，前者剔除、后者保留，都依赖分布式展开。至于 ReturnType 和 Parameters，则是 infer 家族的代表，专攻函数签名的拆解。

把这些机器排在一起会发现：所谓内置工具类型，不过是映射类型与条件类型的“官方预置模板”。理解它们的实现原理，比记忆 API 更重要——因为一旦看穿底盘，你就能自己组装出任何定制机器。

这些标准化机器解决了 80% 的日常类型需求：表单提交用 Partial，配置补丁用 Partial，键值表用 Record，白名单字段用 Pick。车间里备好了通用机器，剩下的 20% 才轮到我们亲手造新机器——那就是实战体操的舞台。

实战类型体操：组合流水线

真正的“体操”发生在机器不够用的时候。假设我们需要 DeepPartial<T>：不仅顶层属性可选，嵌套对象里的每一层属性也都可选。普通的 Partial 只改造一层就停工了，好比车间主管只给货架第一排贴了标签，里层的抽屉一概不管。

解法是把映射类型和条件类型组合成递归流水线：遍历每个键，加可选标记；然后问一句“这个值类型是复合包裹吗？是，就把它送进流水线再改造一层；不是（是 string、number 这类原子类型），就直接放行”。递归的出口是原子类型，保证了流水线不会无限循环。

这类组合在真实项目中俯拾皆是：从函数签名里抠出参数类型、从 Promise<T> 里解包出 T、把数据库实体映射成 API 响应 DTO、按权限裁剪用户字段……每一样都是“映射 + 条件 + infer”三种机器的组合拳。体操的名字由此而来：动作不新，组合见功夫。

回到分拣中心看这条终极流水线：传送带每过一个包裹就贴一张“可选”标签，若发现里面还是箱子，就拆开再走一遍同样的流程；拆到底，看到牙刷、文件这些没法再拆的东西，就放它离开。体操的精髓不在某台机器多神奇，而在于你能否把机器按正确的顺序接起来，让类型像流水线一样自动流转。

AI 应用场景

Python 演示

"""模拟 TS 条件类型与映射类型的小判型器:- conditional_type 对应 T extends U ? X : Y- distributive_conditional 模拟联合类型逐成员展开- mapped_type 对应映射类型 { [K in keyof T]: F(T[K]) }- PromiseBox 演示 infer 解包内部类型"""from typing import Any, Callable, List, TypeVar T = TypeVar("T")U = TypeVar("U")  def conditional_type(t: type, u: type, x: str, y: str) -> str:    """若 t 可赋给 u 则走 X 通道, 否则走 Y 通道"""    try:        return x if issubclass(t, u) else y    except TypeError:        return y  def distributive_conditional(items: List[type], u: type, x: str, y: str) -> List[str]:    """把类型列表当成联合类型, 对每个成员独立判型"""    return [conditional_type(it, u, x, y) for it in items]  def mapped_type(data: dict, transform: Callable[[Any], Any]) -> dict:    """逐键批量施加变换, 生成新对象类型"""    return {key: transform(val) for key, val in data.items()}  class PromiseBox:    """模拟 Promise<T>, inner 是被藏起来的内部类型"""     def __init__(self, inner: type) -> None:        self.inner = inner  def infer_inner(box: PromiseBox):    """扮演 infer R: 从包装中拆出内部类型"""    return box.inner if isinstance(box, PromiseBox) else None  def main() -> None:    results = distributive_conditional([int, str, float], int, "X通道", "Y通道")    print("分布式判定:", results)     raw = {"id": "42", "age": 18}    locked = mapped_type(raw, lambda v: "[readonly]" + str(v))    print("映射加锁:", locked)     box = PromiseBox(str)    print("infer 解包:", infer_inner(box))  if __name__ == "__main__":    main()

1. def conditional_type(t: type, u: type, x: str, y: str) -> str:定义判型函数，四个参数正好对应 T extends U ? X : Y 的四个角色。
2. return x if issubclass(t, u) else y核心判型逻辑：issubclass 扮演 extends 扫描仪，通过走 X，不通过走 Y。
3. def distributive_conditional(items: List[type], u: type, x: str, y: str) -> List[str]:接收一个类型列表，模拟“联合类型拆成逐个成员”。
4. return [conditional_type(it, u, x, y) for it in items]列表推导对每个成员独立判型，就是分布式条件类型的逐成员展开。
5. def mapped_type(data: dict, transform: Callable[[Any], Any]) -> dict:映射类型的通用形态：对每个键值批量施加变换。
6. return {key: transform(val) for key, val in data.items()}字典推导模拟 { [K in keyof T]: F(T[K]) } 的逐键遍历。
7. def infer_inner(box: PromiseBox):模拟 infer R：把包装里的内部类型重新拆出来。
8. results = distributive_conditional([int, str, float], int, "X通道", "Y通道")一次典型的分布式判型调用：三个类型各走各的通道。

常见误区

面试题