第 6 章:联合、交叉与类型收窄
一个变量可能有几种形态,是真实业务里最常见的类型问题。TS 的解法不是"都装进 any",而是把所有可能列成联合,再逼你逐个分支处理。
学习目标
- 会用联合类型描述"几种可能之一",用交叉类型合并多个形状
- 掌握四种收窄手段:
typeof、in、instanceof、判别式属性 - 会写自定义类型守卫和断言函数
- 能用
never做穷尽检查,让漏掉的分支在编译期暴露 - 理解可选属性在联合类型里的分布规则
6.1 联合类型:或者
type ID = string | number
function findById(id: ID) {
// 这里 id 是 string | number,不能直接调用字符串方法
}联合类型表示"可能是其中之一"。在使用前必须先确定是哪一种,这就是下一节要讲的收窄。
联合类型最实用的形态是字面量联合:
type Status = 'pending' | 'paid' | 'refunded'
function label(status: Status): string {
switch (status) {
case 'pending': return '待支付'
case 'paid': return '已支付'
case 'refunded': return '已退款'
}
}
label('canceled') // 报错:不在允许的取值里这一招能让编译器帮你检查"所有状态都处理了吗、有没有写错状态名"。它比 enum 更轻(不产生运行时代码),是现在的主流做法(第 8 章对比)。
可选属性在联合中的分布
type A = { a: string; common?: number }
type B = { b: string; common?: number }
type U = A | B
const u: U = { a: 'x' }
u.common // 可以访问:两个成员都有这个可选属性
u.a // 报错:B 上没有 a规则:只有所有成员都有的属性才能直接访问。想让某个属性在所有分支都有,就把它提到公共层;否则先收窄。
6.2 交叉类型:并且
type WithId = { id: string }
type WithTime = { createdAt: Date }
type Entity = WithId & WithTime
// { id: string; createdAt: Date }交叉类型把多个形状合并。第 5 章提过,对象交叉时属性取并集;同一属性类型冲突时,结果会变成 never:
type Bad = { id: string } & { id: number }
// id: never,任何值都赋不进去原始类型交叉基本都会塌成 never:
type Impossible = string & number // never所以交叉类型主要用于"组合对象形状",不要指望它做类型转换。
6.3 四种收窄手段
收窄(narrowing)是 TS 根据运行时判断,把宽类型缩小到具体类型的过程。它只在同一作用域内的代码流里生效。
先给一张"该用哪种手段"的判断图,后面四小节按这张图展开:
一、typeof:按 JS 类型收窄
function format(value: string | number | boolean): string {
if (typeof value === 'string') {
return value.trim() // 这里 value: string
}
if (typeof value === 'number') {
return value.toFixed(2) // 这里 value: number
}
return value ? '是' : '否' // 这里 value: boolean
}typeof 能识别:string、number、boolean、bigint、symbol、undefined、function、object。
陷阱:typeof null === 'object'。 所以判断对象时要额外排除 null:
if (typeof value === 'object' && value !== null) {
// 这里才真正是一个对象
}二、in:按属性是否存在收窄
type Admin = { role: 'admin'; permissions: string[] }
type Guest = { role: 'guest' }
function check(user: Admin | Guest) {
if ('permissions' in user) {
console.log(user.permissions.length) // 这里 user: Admin
}
}in 适合区分"结构差异明显"的对象。注意它只判断属性是否存在,不保证值是有效数据。
三、instanceof:按构造函数收窄
function handleError(err: unknown) {
if (err instanceof TypeError) {
console.log(err.message) // TypeError
} else if (err instanceof Error) {
console.log(err.stack) // Error
} else {
console.log(String(err)) // 这里 err 是 unknown,只能 String 化
}
}这是处理 catch 捕获值的标准写法。unknown 不能直接访问 .message,必须先用 instanceof 收窄。
四、判别式属性(最推荐)
给每种形态加一个字面量类型的"标签字段",TS 就能自动按标签分流:
type Result =
| { ok: true; data: string }
| { ok: false; error: string }
function unwrap(result: Result): string {
if (result.ok) {
return result.data // 这里自动收窄成成功分支
}
throw new Error(result.error) // 这里自动收窄成失败分支
}这比 in 和 typeof 都可靠,因为标签是业务自己定义的,不会被运行时类型骗到。接口返回值、状态机、事件对象,都应该用判别式联合来建模。
// 一个更接近真实业务的例子
type UploadState =
| { status: 'idle' }
| { status: 'uploading'; progress: number }
| { status: 'success'; url: string }
| { status: 'failed'; reason: string }
function render(state: UploadState) {
switch (state.status) {
case 'idle': return '等待上传'
case 'uploading': return `上传中 ${state.progress}%`
case 'success': return `完成:${state.url}`
case 'failed': return `失败:${state.reason}`
}
}每个分支能访问的字段都不一样,而且不可能访问到不属于该状态的字段。这就是判别式联合最大的价值:把"状态和字段的对应关系"写进类型,而不是靠注释维护。
其他会被自动收窄的写法
// 真值判断
function print(name?: string) {
if (name) {
name.toUpperCase() // 排除 undefined 和空字符串
}
}
// 相等判断
type Mode = 'a' | 'b' | 'c'
function pick(mode: Mode) {
if (mode === 'a') {
// mode: 'a'
}
}
// 数组过滤配合类型守卫(6.4 节)6.4 自定义类型守卫
有时候判断逻辑比较复杂,typeof / in 不够用。可以写一个返回 value is T 的函数:
interface User {
id: number
name: string
}
function isUser(value: unknown): value is User {
return (
typeof value === 'object' &&
value !== null &&
typeof (value as User).id === 'number' &&
typeof (value as User).name === 'string'
)
}
function handle(data: unknown) {
if (isUser(data)) {
console.log(data.name) // 这里 data 是 User
}
}value is User 这个返回值类型叫类型谓词。它必须写在返回值位置,TS 才会在 if 之后按它收窄。
它不会自动校验——判断逻辑要你自己写。写错了(比如只检查了 id 没检查 name),TS 不会发现,运行时照样出错。所以守卫函数里的检查必须真的覆盖你声称的类型。
这种守卫最常用的地方是过滤数组:
const raw: (string | null)[] = ['a', null, 'b']
// 普通 filter 不会改变元素类型
const a = raw.filter((x) => x !== null) // 仍然是 (string | null)[]
// 用类型谓词,结果变成 string[]
const b = raw.filter((x): x is string => x !== null)这个差别很关键:filter 的类型签名不会自动根据你的判断收窄,必须显式写 x is string。
断言函数
asserts 是另一种守卫,用于"不满足就抛异常"的场景:
function assertIsString(value: unknown): asserts value is string {
if (typeof value !== 'string') {
throw new TypeError('必须是字符串')
}
}
function process(input: unknown) {
assertIsString(input)
input.toUpperCase() // 断言之后,input 已经是 string
}它和类型守卫的区别是:守卫返回布尔值、靠 if 收窄;断言函数不返回值、直接让后续代码都按新类型处理。
6.5 never 与穷尽检查
判别式联合的分支如果漏了一个,编译器默认不会报错——除非你用 never 兜底。
type Status = 'pending' | 'paid' | 'refunded'
function assertNever(value: never): never {
throw new Error(`未处理的状态:${JSON.stringify(value)}`)
}
function label(status: Status): string {
switch (status) {
case 'pending': return '待支付'
case 'paid': return '已支付'
case 'refunded': return '已退款'
default:
return assertNever(status) // 漏一个状态,这里就报错
}
}原理:所有分支都覆盖时,default 里的 status 会被收窄成 never,而 never 可以赋给任何参数,所以 assertNever(status) 合法。一旦新增一个状态忘了处理,status 就不是 never 了,编译立刻失败。
这是 TS 里性价比最高的一个技巧:以后给状态机加枚举值,编译器会精确地告诉你哪些地方要改,而不是等用户点出来。
6.6 收窄会失效的地方
收窄依赖"编译器能证明这个变量没被改过"。下面这些写法会打断它。
// 1. 回调里收窄失效(因为回调可能在之后才执行)
function f(value: string | null) {
if (value !== null) {
setTimeout(() => {
value.toUpperCase() // 报错:value 可能又变成 null?
})
}
}
// 解法:先赋给一个 const
function f2(value: string | null) {
if (value !== null) {
const v = value
setTimeout(() => v.toUpperCase())
}
}// 2. 重新赋值会重置收窄
let value: string | number = 'a'
if (typeof value === 'string') {
value = 1 // 重新赋值,类型回到 string | number
// 这里不能再当 string 用
}
// 3. 解构后再判断原始对象,部分场景失效
const obj: { a?: string } = {}
const { a } = obj
if (a) {
a.toUpperCase() // 这个没问题
}// 4. 非空断言会"骗"编译器,让后续判断失去意义
function g(user: User | null) {
const name = user!.name // 强行通过,运行时可能崩
}6.7 常见误区
误区一:遇到联合类型就用 as 断言成具体类型。 → 断言不做运行时检查,等于放弃了这一章所有保护。用收窄。
误区二:用 typeof 判断对象后直接访问属性。 → 忘记 typeof null === 'object',要加 value !== null。
误区三:判别式标签用了 string 而不是字面量。 → { status: string } 无法用于收窄,必须是 { status: 'success' } 这种字面量类型。
误区四:以为写了 is T 就会自动做校验。 → 谓词只是给编译器看的承诺,检查逻辑得自己写,而且必须真覆盖。
误区五:switch 不写 default 也不做穷尽检查。 → 以后新增状态时,编译器不会提醒你漏了分支。加上 assertNever。
误区六:在 setTimeout 回调里继续用外面收窄过的变量。 → 先把收窄结果赋给 const 再用。
本章小结
| 要点 | 说明 |
|---|---|
| 联合类型 | A | B 表示几种可能之一;字面量联合可替代枚举 |
| 交叉类型 | A & B 合并形状;属性冲突会变 never |
| 四种收窄 | typeof、in、instanceof、判别式属性 |
| 判别式联合 | 加字面量标签字段,最可靠、最适合业务状态 |
| 类型守卫 | value is T,配合 filter 才能改变数组元素类型 |
| 断言函数 | asserts value is T,不满足就抛异常 |
| 穷尽检查 | default: assertNever(status),漏分支直接编译失败 |
| 收窄失效 | 回调、重新赋值、非空断言都会打断收窄,先存 const |
下一章预告
前面每个类型都是具体的。但如果一个函数要处理"任意类型",还要求"取出和放回的是同一种类型"呢?这就是泛型要解决的问题,也是读懂第三方库类型的关键。
👉 第 7 章:泛型