TypeScript高级类型实战：条件类型、模板字面量类型与类型推导技巧

TypeScript条件类型深入解析

TypeScript的条件类型（Conditional Types）是类型系统中最强大的特性之一，它允许根据类型关系动态选择结果类型。条件类型的语法形式为T extends U ? X : Y，类似于三目运算符，但在类型层面工作。掌握条件类型是写出类型安全且灵活的TypeScript代码的关键。

条件类型的核心价值在于类型层面的分支逻辑。与函数中用if/else处理值不同，条件类型在编译时根据类型关系做出决策，让类型系统承担更多运行时才能做的判断。

分布式条件类型与never类型

当条件类型作用于联合类型时，TypeScript会自动分发（distribute），即对联合类型的每个成员分别求值再合并。这个行为是条件类型最容易被误解的地方。

// 分布式条件类型
type ToArray<T> = T extends unknown ? T[] : never

type Result = ToArray<string | number>
// 等价于: string[] | number[]
// 而非: (string | number)[]

// 禁用分发：用[T]包裹
type ToArrayNoDistribute<T> = [T] extends [unknown] ? T[] : never

type Result2 = ToArrayNoDistribute<string | number>
// 结果: (string | number)[]

never类型在条件类型中有特殊作用。当联合类型的某个分支解析为never时，它会被自动从结果中剔除。利用这个特性可以实现类型过滤：

// 从联合类型中剔除null和undefined
type NonNullable<T> = T extends null | undefined ? never : T

type Cleaned = NonNullable<string | null | number | undefined>
// 结果: string | number

infer关键字与类型提取

infer关键字只能在条件类型的extends子句中使用，用于声明一个待推断的类型变量。它让TypeScript从具体类型中提取内部类型信息。

// 提取函数返回值类型
type MyReturnType<T> = T extends (...args: any[]) => infer R ? R : never

type FnReturn = MyReturnType<() => { name: string; age: number }>
// 结果: { name: string; age: number }

// 提取Promise内部值类型（递归解包）
type Awaited<T> = T extends Promise<infer U> ? Awaited<U> : T

type PromiseValue = Awaited<Promise<Promise<string>>>
// 结果: string

// 提取数组元素类型
type ElementOf<T> = T extends (infer E)[] ? E : never

type Item = ElementOf<string[]>
// 结果: string

infer不仅可以提取单个类型，还可以在函数参数位置使用多个infer提取元组中的类型分布：

// 提取函数参数类型为元组
type Parameters<T> = T extends (...args: infer P) => any ? P : never

// 提取构造函数参数和实例类型
type ConstructorParameters<T> = 
  T extends new (...args: infer P) => any ? P : never

type InstanceType<T> = 
  T extends new (...args: any[]) => infer I ? I : never

模板字面量类型与字符串操作

TypeScript 4.1引入的模板字面量类型（Template Literal Types）让类型系统具备字符串拼接和模式匹配能力，结合条件类型和映射类型可以实现极强类型安全的API。

// CSS属性类型安全
type CSSUnit = 'px' | 'em' | 'rem' | '%' | 'vh' | 'vw'
type CSSValue = `${number}${CSSUnit}`

const width: CSSValue = '100px'   // OK
const height: CSSValue = '50vh'  // OK
// const invalid: CSSValue = '100'   // Error

// 事件处理器类型推导
type EventName<T extends string> = `on${Capitalize<T>}`
type ClickEvent = EventName<'click'>  // 'onClick'
type FocusEvent = EventName<'focus'>  // 'onFocus'

// 递归类型：Deep Readonly
type DeepReadonly<T> = {
  readonly [K in keyof T]: T[K] extends object 
    ? (T[K] extends Function ? T[K] : DeepReadonly<T[K]>)
    : T[K]
}

interface Config {
  db: { host: string; port: number }
  cache: { ttl: number; prefix: string }
  replicas: number
}

type ReadonlyConfig = DeepReadonly<Config>

类型体操实战：类型安全的EventEmitter

结合条件类型、模板字面量类型和映射类型，构建一个完全类型安全的事件发射器：

// 类型安全的事件系统
type EventMap = {
  'user:login': { userId: string; timestamp: number }
  'user:logout': { userId: string }
  'data:update': { table: string; id: string; changes: Record<string, unknown> }
  'data:delete': { table: string; id: string }
}

type EventKey = keyof EventMap

class TypeSafeEmitter {
  private handlers = new Map<EventKey, Set<Function>>()
  
  on<E extends EventKey>(
    event: E,
    handler: (payload: EventMap[E]) => void
  ): void {
    if (!this.handlers.has(event)) {
      this.handlers.set(event, new Set())
    }
    this.handlers.get(event)!.add(handler)
  }
  
  emit<E extends EventKey>(event: E, payload: EventMap[E]): void {
    this.handlers.get(event)?.forEach(handler => handler(payload))
  }
  
  off<E extends EventKey>(
    event: E,
    handler: (payload: EventMap[E]) => void
  ): void {
    this.handlers.get(event)?.delete(handler)
  }
}

// 使用示例
const emitter = new TypeSafeEmitter()
emitter.on('user:login', (payload) => {
  console.log(payload.userId, payload.timestamp)
})

emitter.emit('user:login', { userId: '123', timestamp: Date.now() })

类型推导的性能与可读性平衡

复杂的类型推导会增加编译时间，尤其在大型项目中。几个实用建议：优先使用内置工具类型（Partial、Required、Pick、Omit等），它们经过优化且语义清晰。自定义条件类型超过3层嵌套时考虑拆分为中间类型别名，提升可读性和编译速度。避免在热路径（频繁import的公共类型文件）中放置深度递归的条件类型，这些类型会在每次编译时重新求值。

类型系统的目标是让错误在编译期暴露，而非追求类型体操的复杂度。好的TypeScript类型定义读起来像文档，使用者无需查看实现就能知道接口的约束。条件类型和模板字面量类型是工具，目的是让代码更安全、更易维护，而非更难理解。