Skip to content
Lv1TypeScript进度 6 / 14

第 6 章:联合、交叉与类型收窄 ​

一个变量可能有几种形态,是真实业务里最常见的类型问题。TS 的解法不是"都装进 any",而是把所有可能列成联合,再逼你逐个分支处理。


学习目标 ​

  • 会用联合类型描述"几种可能之一",用交叉类型合并多个形状
  • 掌握四种收窄手段:typeof、in、instanceof、判别式属性
  • 会写自定义类型守卫和断言函数
  • 能用 never 做穷尽检查,让漏掉的分支在编译期暴露
  • 理解可选属性在联合类型里的分布规则

6.1 联合类型:或者 ​

typescript
type ID = string | number

function findById(id: ID) {
  // 这里 id 是 string | number,不能直接调用字符串方法
}

联合类型表示"可能是其中之一"。在使用前必须先确定是哪一种,这就是下一节要讲的收窄。

联合类型最实用的形态是字面量联合:

typescript
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 章对比)。

可选属性在联合中的分布 ​

typescript
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 交叉类型:并且 ​

typescript
type WithId = { id: string }
type WithTime = { createdAt: Date }

type Entity = WithId & WithTime
// { id: string; createdAt: Date }

交叉类型把多个形状合并。第 5 章提过,对象交叉时属性取并集;同一属性类型冲突时,结果会变成 never:

typescript
type Bad = { id: string } & { id: number }
// id: never,任何值都赋不进去

原始类型交叉基本都会塌成 never:

typescript
type Impossible = string & number  // never

所以交叉类型主要用于"组合对象形状",不要指望它做类型转换。


6.3 四种收窄手段 ​

收窄(narrowing)是 TS 根据运行时判断,把宽类型缩小到具体类型的过程。它只在同一作用域内的代码流里生效。

先给一张"该用哪种手段"的判断图,后面四小节按这张图展开:

一、typeof:按 JS 类型收窄 ​

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

typescript
if (typeof value === 'object' && value !== null) {
  // 这里才真正是一个对象
}

二、in:按属性是否存在收窄 ​

typescript
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:按构造函数收窄 ​

typescript
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 就能自动按标签分流:

typescript
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 都可靠,因为标签是业务自己定义的,不会被运行时类型骗到。接口返回值、状态机、事件对象,都应该用判别式联合来建模。

typescript
// 一个更接近真实业务的例子
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}`
  }
}

每个分支能访问的字段都不一样,而且不可能访问到不属于该状态的字段。这就是判别式联合最大的价值:把"状态和字段的对应关系"写进类型,而不是靠注释维护。

其他会被自动收窄的写法 ​

typescript
// 真值判断
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 的函数:

typescript
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 不会发现,运行时照样出错。所以守卫函数里的检查必须真的覆盖你声称的类型。

这种守卫最常用的地方是过滤数组:

typescript
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 是另一种守卫,用于"不满足就抛异常"的场景:

typescript
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 兜底。

typescript
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 收窄会失效的地方 ​

收窄依赖"编译器能证明这个变量没被改过"。下面这些写法会打断它。

typescript
// 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())
  }
}
typescript
// 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()    // 这个没问题
}
typescript
// 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 章:泛型

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