Skip to content
Lv1TypeScript进度 11 / 14

第 11 章:类型运算入门 ​

这一章不教"类型体操",只教四件事:怎么从已有类型里取键、取值、批量改造、挑几个字段。学完你能看懂 Omit<T, K> 这类日常工具类型的来龙去脉,也不会被面试题带偏。


学习目标 ​

  • 会用 keyof 和索引访问 T[K],从对象类型里取出键和值的联合
  • 理解映射类型的基本形式,知道 Partial、Readonly 是怎么"造"出来的
  • 会挑用内置工具类型:Partial、Pick、Omit、Record、ReturnType
  • 知道 infer 只是在"推测返回类型"这一层够用就行
  • 判断一段类型运算该不该写:什么时候该停手

11.1 类型也能被"计算" ​

前面写的类型都是"直接描述",比如:

typescript
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:取键 ​

typescript
interface User {
  id: number
  name: string
  email: string
}

type UserKeys = keyof User
// 'id' | 'name' | 'email'

有了键的联合,就能做"只允许传存在的键":

typescript
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 取到:

typescript
type Dict = { [key: string]: number }
type DictKeys = keyof Dict   // string | number(JS 里数字键也会转成字符串)

11.3 索引访问与 typeof ​

T[K]:按键取值类型 ​

typescript
type UserName = User['name']              // string
type UserValues = User[keyof User]        // number | string

User[keyof User] 是最常用的写法之一,意思是"把所有键的值类型取出来,合成联合"。第 8 章用 as const 造枚举时,用的就是这个:

typescript
const ROLES = { Admin: 'admin', Editor: 'editor' } as const
type Role = typeof ROLES[keyof typeof ROLES]   // 'admin' | 'editor'

数组也能索引,T[number] 表示"元素类型":

typescript
type Names = string[]
type Name = Names[number]   // string

const LIST = ['a', 'b'] as const
type Item = typeof LIST[number]   // 'a' | 'b'

typeof:从值取类型 ​

注意它在类型位置和值位置的含义完全不同:

typescript
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 的典型用途是给常量、默认配置、函数返回值补类型,避免手写一遍:

typescript
const DEFAULT_OPTIONS = { timeout: 3000, retries: 2 }
type Options = typeof DEFAULT_OPTIONS

11.4 映射类型:批量改造属性 ​

映射类型的语法:

typescript
type Clone<T> = {
  [K in keyof T]: T[K]
}

读法:"对于 T 的每一个键 K,产出同名属性,类型是 T[K]"。结果和 T 长得一样。

真正有用的是在"产出"这一步做改造。

全部变可选 ​

typescript
type MyPartial<T> = {
  [K in keyof T]?: T[K]
}

type UserPatch = MyPartial<User>
// { id?: number; name?: string; email?: string }

全部变只读 ​

typescript
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]去掉只读
typescript
type Concrete<T> = {
  [K in keyof T]-?: T[K]        // 所有字段变必填
}

type ReadWrite<T> = {
  -readonly [K in keyof T]: T[K]  // 所有字段变可写
}

改值的类型 ​

typescript
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 }
typescript
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
typescript
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 解析后的类型
typescript
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 最实用的场景是:某个函数的返回类型很复杂,你不想手抄一遍。

typescript
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
typescript
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>   // string

Exclude 的实际用途很具体:从联合里剔除一个分支。比如"所有状态减去已删除"。


11.6 一个完整的实战:DTO 的三种派生形态 ​

后端接口通常需要三种类型:

typescript
interface User {
  id: string
  name: string
  email: string
  password: string
  createdAt: Date
}
typescript
// 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 里某几个字段被更新,再加一层:

typescript
type EditableField = 'name' | 'email'
type UpdateUserInput2 = Partial<Pick<User, EditableField>>

11.7 infer:点到为止 ​

infer 只能出现在条件类型里,作用是"从某个类型里把一部分揪出来"。你不需要会写复杂用法,但要认识它,因为很多库的类型都用了它。

typescript
type MyReturnType<T> = T extends (...args: any[]) => infer R ? R : never

读法:"如果 T 是一个函数,那么把它的返回值类型记作 R,结果就是 R;否则是 never。"

infer R 就是"在这里先占个位,等匹配成功时把真实类型填进来"。

另一个常见形式是取 Promise 的值:

typescript
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 可能比三个条件类型更清楚

一条实用原则:类型要服务可读性。 如果推导出来的类型让人看不懂,不如老老实实写清楚。

typescript
// ❌ 炫技:没人一眼看懂
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 的库补上类型。

👉 第 12 章:声明文件与第三方类型

本文阅读--次|全站访问--次|访客--人