第 11 章:类型运算入门
这一章不教"类型体操",只教四件事:怎么从已有类型里取键、取值、批量改造、挑几个字段。学完你能看懂
Omit<T, K>这类日常工具类型的来龙去脉,也不会被面试题带偏。
学习目标
- 会用
keyof和索引访问T[K],从对象类型里取出键和值的联合 - 理解映射类型的基本形式,知道
Partial、Readonly是怎么"造"出来的 - 会挑用内置工具类型:
Partial、Pick、Omit、Record、ReturnType - 知道
infer只是在"推测返回类型"这一层够用就行 - 判断一段类型运算该不该写:什么时候该停手
11.1 类型也能被"计算"
前面写的类型都是"直接描述",比如:
interface User {
id: number
name: string
email: string
}但很多时候你想要的是"基于 User 派生出来的新类型":
- 更新用户时,所有字段都可选 →
Partial<User> - 对外返回时,去掉
email→Omit<User, 'email'> - 表单里只要
name和email→Pick<User, 'name' | 'email'>
这些不是手写的,是从 User 算出来的。TS 提供了一套"类型层面的运算符",让类型可以像值一样被加工。
先记住四件武器:
| 武器 | 作用 | 类比 |
|---|---|---|
keyof T | 取 T 的所有键,组成联合 | Object.keys() 的类型版 |
T[K] | 取 T 在键 K 上的类型 | obj[key] 的类型版 |
typeof value | 取一个值的类型 | "把这个变量的类型拿来用" |
{ [K in keyof T]: ... } | 遍历键批量改造 | map 的类型版 |
11.2 keyof:取键
interface User {
id: number
name: string
email: string
}
type UserKeys = keyof User
// 'id' | 'name' | 'email'有了键的联合,就能做"只允许传存在的键":
function getField<T, K extends keyof T>(obj: T, key: K): T[K] {
return obj[key]
}
const user: User = { id: 1, name: '陌阡', email: 'a@b.c' }
getField(user, 'name') // string
getField(user, 'age') // 报错:'age' 不在键里这就是第 7 章那个 K extends keyof T 的完整解释:keyof 给出合法键的集合,T[K] 给出该键对应的类型。
索引签名也能被 keyof 取到:
type Dict = { [key: string]: number }
type DictKeys = keyof Dict // string | number(JS 里数字键也会转成字符串)11.3 索引访问与 typeof
T[K]:按键取值类型
type UserName = User['name'] // string
type UserValues = User[keyof User] // number | stringUser[keyof User] 是最常用的写法之一,意思是"把所有键的值类型取出来,合成联合"。第 8 章用 as const 造枚举时,用的就是这个:
const ROLES = { Admin: 'admin', Editor: 'editor' } as const
type Role = typeof ROLES[keyof typeof ROLES] // 'admin' | 'editor'数组也能索引,T[number] 表示"元素类型":
type Names = string[]
type Name = Names[number] // string
const LIST = ['a', 'b'] as const
type Item = typeof LIST[number] // 'a' | 'b'typeof:从值取类型
注意它在类型位置和值位置的含义完全不同:
const config = { level: 'debug', retries: 3 }
type Config = typeof config
// { level: string; retries: number }
// 配合 as const 才有字面量
const config2 = { level: 'debug' } as const
type Config2 = typeof config2 // { readonly level: "debug" }typeof 的典型用途是给常量、默认配置、函数返回值补类型,避免手写一遍:
const DEFAULT_OPTIONS = { timeout: 3000, retries: 2 }
type Options = typeof DEFAULT_OPTIONS11.4 映射类型:批量改造属性
映射类型的语法:
type Clone<T> = {
[K in keyof T]: T[K]
}读法:"对于 T 的每一个键 K,产出同名属性,类型是 T[K]"。结果和 T 长得一样。
真正有用的是在"产出"这一步做改造。
全部变可选
type MyPartial<T> = {
[K in keyof T]?: T[K]
}
type UserPatch = MyPartial<User>
// { id?: number; name?: string; email?: string }全部变只读
type MyReadonly<T> = {
readonly [K in keyof T]: T[K]
}去掉可选与只读
映射类型支持修饰符的加减:
| 语法 | 作用 |
|---|---|
[K in keyof T]? | 加可选 |
[K in keyof T]-? | 去掉可选 |
readonly [K in keyof T] | 加只读 |
-readonly [K in keyof T] | 去掉只读 |
type Concrete<T> = {
[K in keyof T]-?: T[K] // 所有字段变必填
}
type ReadWrite<T> = {
-readonly [K in keyof T]: T[K] // 所有字段变可写
}改值的类型
type Stringify<T> = {
[K in keyof T]: string
}
// 所有字段都变成 string,常用于"表单输入都是字符串"的场景这一招在表单里特别实用:后端返回 id: number,但输入框里拿到的是字符串,两者用 Stringify<T> 和提交时的转换函数配合处理。
11.5 内置工具类型:直接能用
TS 自带一批工具类型,原理就是上面那些运算。记住它们,比记住怎么自己写更划算。
结构改造类
| 工具类型 | 作用 | 手工等价 |
|---|---|---|
Partial<T> | 所有属性变可选 | { [K in keyof T]?: T[K] } |
Required<T> | 所有属性变必填 | { [K in keyof T]-?: T[K] } |
Readonly<T> | 所有属性变只读 | { readonly [K in keyof T]: T[K] } |
Record<K, V> | 构造键为 K、值为 V 的对象 | { [P in K]: V } |
type UserPatch = Partial<User>
type RequiredUser = Required<UserPatch>
type RoleMap = Record<'admin' | 'editor', { label: string }>挑选字段类
| 工具类型 | 作用 |
|---|---|
Pick<T, K> | 从 T 里挑出键 K |
Omit<T, K> | 从 T 里去掉键 K |
type UserPreview = Pick<User, 'id' | 'name'>
// { id: number; name: string }
type PublicUser = Omit<User, 'email'>
// { id: number; name: string }Pick 和 Omit 是使用频率最高的两个。Omit 的实现就是 Pick<T, Exclude<keyof T, K>>——先算"剩下的键",再挑出来。
从函数类型取东西
| 工具类型 | 作用 |
|---|---|
Parameters<F> | 取函数参数类型组成的元组 |
ReturnType<F> | 取函数返回类型 |
Awaited<T> | 取 Promise 解析后的类型 |
async function fetchUser(id: string) {
return { id, name: 'x' }
}
type FetchParams = Parameters<typeof fetchUser> // [id: string]
type FetchResult = Awaited<ReturnType<typeof fetchUser>>
// { id: string; name: string }ReturnType 最实用的场景是:某个函数的返回类型很复杂,你不想手抄一遍。
const store = createStore({ ... })
type State = ReturnType<typeof store.getState>这行在 Redux / Zustand 项目里到处都是——让类型跟着实现走,而不是手写一份可能过期的类型。
联合类型运算
| 工具类型 | 作用 |
|---|---|
Exclude<T, U> | 从 T 里排除 U |
Extract<T, U> | 从 T 里只保留 U |
NonNullable<T> | 去掉 null 和 undefined |
type Status = 'pending' | 'paid' | 'refunded'
type ActiveStatus = Exclude<Status, 'refunded'> // 'pending' | 'paid'
type FinalStatus = Extract<Status, 'paid' | 'refunded'> // 'paid' | 'refunded'
type MaybeName = string | null | undefined
type Name = NonNullable<MaybeName> // stringExclude 的实际用途很具体:从联合里剔除一个分支。比如"所有状态减去已删除"。
11.6 一个完整的实战:DTO 的三种派生形态
后端接口通常需要三种类型:
interface User {
id: string
name: string
email: string
password: string
createdAt: Date
}// 1. 创建时:不传 id 和 createdAt(服务端生成)
type CreateUserInput = Omit<User, 'id' | 'createdAt'>
// 2. 更新时:所有字段可选,且不能改 id
type UpdateUserInput = Partial<Omit<User, 'id'>>
// 3. 对外返回:去掉密码
type UserResponse = Omit<User, 'password'>三行类型,把"增、改、查"三种接口契约写清楚了。以后 User 加字段,三种形态自动跟着变——这就是类型运算的真正价值:接口变了,类型自动同步,不用维护三份。
如果只允许 User 里某几个字段被更新,再加一层:
type EditableField = 'name' | 'email'
type UpdateUserInput2 = Partial<Pick<User, EditableField>>11.7 infer:点到为止
infer 只能出现在条件类型里,作用是"从某个类型里把一部分揪出来"。你不需要会写复杂用法,但要认识它,因为很多库的类型都用了它。
type MyReturnType<T> = T extends (...args: any[]) => infer R ? R : never读法:"如果 T 是一个函数,那么把它的返回值类型记作 R,结果就是 R;否则是 never。"
infer R 就是"在这里先占个位,等匹配成功时把真实类型填进来"。
另一个常见形式是取 Promise 的值:
type UnwrapPromise<T> = T extends Promise<infer V> ? V : T
type A = UnwrapPromise<Promise<string>> // string
type B = UnwrapPromise<number> // number日常开发中,infer 的正确用法是"读懂,而不是自己写"。ReturnType、Parameters、Awaited 已经覆盖了大多数需求,遇到更复杂的场景,先找现成的库类型(如 type-fest),不要自己从零推导。
11.8 该停手的地方
类型运算能做的事没有上限(理论上 TS 的类型系统能表达很复杂的东西),但这不代表应该做。
判断标准:
| 信号 | 说明 |
|---|---|
| 编译明显变慢 | 递归类型、深度条件类型会显著拖慢 tsc 和编辑器 |
| 报错看不懂 | 类型体操的报错通常是几十行嵌套,排查成本远超收益 |
| 只有作者能改 | 团队里第二个人不敢动,这段类型就成了技术债 |
用 @ts-expect-error 兜底 | 说明类型已经和实际行为脱节 |
| 为了少写几行 | 手写一个 interface 可能比三个条件类型更清楚 |
一条实用原则:类型要服务可读性。 如果推导出来的类型让人看不懂,不如老老实实写清楚。
// ❌ 炫技:没人一眼看懂
type DeepPartial<T> = T extends object
? { [K in keyof T]?: DeepPartial<T[K]> }
: T
// ✅ 大多数场景只需要一层
type ConfigPatch = Partial<Config>11.9 常见误区
误区一:keyof 能取到值的类型。 → keyof T 取的是键的联合。值的联合要用 T[keyof T]。
误区二:typeof 和 JS 的 typeof 是一回事。 → 类型位置的 typeof value 是"取这个值的类型",和运行时的 typeof 运算符无关。
误区三:Omit 可以删掉联合类型里的成员。 → 不行,Omit 只作用于对象的键。删联合成员用 Exclude。
误区四:Partial<T> 是深层的。 → 只作用第一层。嵌套对象仍然是必填的,需要自己写递归版本(但要慎用,见 11.8)。
误区五:自己写映射类型比用内置的好。 → 内置工具类型已经覆盖 90% 场景,自己写的版本容易漏掉修饰符、索引签名等边界情况。
本章小结
| 要点 | 说明 |
|---|---|
keyof T | 取键的联合:'id' | 'name' |
T[K] | 取某键的值类型;T[keyof T] 取值联合 |
typeof value | 从值取类型,常配合 as const |
| 映射类型 | { [K in keyof T]: ... },可批量加/去可选与只读 |
| 结构工具 | Partial、Required、Readonly、Record |
| 字段工具 | Pick、Omit,最常用的两个 |
| 函数工具 | Parameters、ReturnType、Awaited |
| 联合工具 | Exclude、Extract、NonNullable |
infer | 条件类型里"猜"出一部分类型,以读懂为主 |
| 停手标准 | 编译变慢、报错难读、只有作者能改,就该退回手写 |
下一章预告
类型运算解决的是"自己项目里的类型"。但真实项目一定会用到没有类型的第三方库——下一章讲
.d.ts声明文件:怎么读、怎么写、怎么给一个纯 JS 的库补上类型。