Skip to content
Lv1TypeScript进度 7 / 14

第 7 章:泛型 ​

泛型的本质是"把类型也当参数传进去"。它让你只写一份代码,却能在每种类型上都保持精确。


学习目标 ​

  • 说清泛型解决了什么问题,能自己写出泛型函数
  • 掌握泛型约束 extends,知道 K extends keyof T 这类写法的用途
  • 会给泛型加默认值,理解"推断优先、显式其次"
  • 能读懂第三方库里的 Array<T>、Promise<T>、Props<T> 这类类型
  • 避开"过度泛型化"和"用泛型掩盖 any"这两个坑

7.1 为什么需要泛型 ​

先看一个不用泛型的函数:

typescript
function firstOfString(arr: string[]): string | undefined {
  return arr[0]
}

function firstOfNumber(arr: number[]): number | undefined {
  return arr[0]
}

两份代码逻辑完全一样,只因为类型不同就得写两遍。用 any 能合成一份,但类型信息丢了:

typescript
function firstAny(arr: any[]): any {
  return arr[0]
}

const names = ['a', 'b']
const n = firstAny(names)   // n 是 any,后面所有操作都不受检查
n.toFixed(2)                // 不报错,运行时崩

泛型要解决的就是这个矛盾:代码只写一份,类型信息一点不丢。

typescript
function first<T>(arr: T[]): T | undefined {
  return arr[0]
}

const names = ['a', 'b']
const n = first(names)      // n: string | undefined
n?.toUpperCase()            // 类型正确

const nums = [1, 2, 3]
const m = first(nums)       // m: number | undefined

<T> 里的 T 是类型参数,T[] 表示"元素是 T 的数组",返回 T | undefined 表示"和元素同类型或没有"。T 不是 any,它是调用时被推断出来的具体类型。

<T> 只是社区习惯(T 来自 Type、Type parameter)。也可以写 <Item>、<TData>,可读性更好。单字母适合简单场景,多个类型参数时建议用有含义的名字:<TKey, TValue>。


7.2 泛型出现在哪些地方 ​

泛型函数 ​

typescript
function toPair<T>(value: T): [T, T] {
  return [value, value]
}

toPair('x')    // [string, string]
toPair(1)      // [number, number]

泛型接口 ​

typescript
interface ApiResponse<T> {
  code: number
  message: string
  data: T
}

type UserResponse = ApiResponse<{ id: number; name: string }>

这是前后端协作里最常用的形式:外层信封固定,data 的内容随接口而变。

泛型类型别名 ​

typescript
type Nullable<T> = T | null
type List<T> = T[]

const maybeName: Nullable<string> = null

泛型类 ​

typescript
class Stack<T> {
  private items: T[] = []

  push(item: T): void {
    this.items.push(item)
  }

  pop(): T | undefined {
    return this.items.pop()
  }

  size(): number {
    return this.items.length
  }
}

const stack = new Stack<number>()
stack.push(1)
stack.pop()   // number | undefined

泛型约束:extends ​

不约束的 T 是"任意类型",你什么属性都访问不了:

typescript
function getLength<T>(value: T): number {
  return value.length   // 报错:T 上不存在 length
}

加约束就能用了:

typescript
function getLength<T extends { length: number }>(value: T): number {
  return value.length
}

getLength('abc')     // 3
getLength([1, 2])    // 2
getLength(123)       // 报错:number 没有 length

extends 在这里不是"继承",而是"必须满足这个形状"。它是结构化类型的用法,不是 Java 的类继承。

再看一个实战里高频的约束:

typescript
function pluck<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key]
}

const user = { id: 1, name: 'a' }
pluck(user, 'name')   // string
pluck(user, 'age')    // 报错:'age' 不在 user 的键里

K extends keyof T 的意思是"K 必须是 T 的某个键"。这样 obj[key] 才合法,而且返回类型 T[K] 精确到该键对应的类型。第 11 章会继续用 keyof 和索引访问。

默认类型参数 ​

typescript
interface Paginated<T = unknown> {
  items: T[]
  total: number
}

type AnyPage = Paginated            // T 默认是 unknown
type UserPage = Paginated<{ id: number }>

默认值适合"大多数调用方用不上这个参数"的场景。


7.3 推断优先,显式其次 ​

泛型参数通常不用手写,编译器从实参推出来:

typescript
function wrap<T>(value: T): { value: T } {
  return { value }
}

const a = wrap('hello')   // { value: string }

但有时候推不出来,需要显式指定:

typescript
// 返回空数组,没有实参可推断
function createList<T>(): T[] {
  return []
}

const list = createList<string>()   // 显式指定 T = string
typescript
// 需要"比实参更宽/更窄"的类型
function parse<T>(json: string): T {
  return JSON.parse(json) as T
}

const user = parse<{ id: number }>('{"id":1}')

第二种写法要小心:parse<T> 只是把 JSON.parse 的结果贴了个标签,没有任何校验。这是泛型最容易被误用的地方——泛型不会验证数据,它只是搬运类型。

实战原则:能推断就别显式写。显式写出 <string> 的地方,往往意味着这里有个"类型断裂",值得多看一眼。


7.4 读懂第三方库里的泛型 ​

你不需要会写多复杂的泛型,但必须会读。下面这些几乎每天都会遇到。

类型读法例子
Array<T> / T[]元素为 T 的数组string[]
Promise<T>异步结果是 TPromise<User>
Record<K, V>键为 K、值为 V 的对象Record<string, number>
Map<K, V> / Set<T>键值映射 / 集合Map<string, User>
Partial<T>T 的所有属性变可选Partial<User>
Readonly<T>T 的所有属性变只读Readonly<Config>
Pick<T, K>从 T 里挑几个键Pick<User, 'id' | 'name'>
Omit<T, K>从 T 里去掉几个键Omit<User, 'password'>
ReturnType<F>函数 F 的返回类型ReturnType<typeof fetch>

这些工具类型的原理是"映射类型",第 11 章讲。现在先做到看到 <...> 不慌,能翻译成大白话。

一个真实的例子:

typescript
type User = { id: number; name: string; password: string }

// 对外返回的用户信息,去掉密码
type PublicUser = Omit<User, 'password'>   // { id: number; name: string }

// 更新用户时,字段都可以不传
type UserPatch = Partial<PublicUser>       // { id?: number; name?: string }

这段代码的含义,用中文说就是"公开用户 = 用户去掉密码"、"更新补丁 = 公开用户的所有字段都变可选"。能这样翻译,说明你读懂泛型了。


7.5 泛型的实战:封装一个请求函数 ​

这是后端 / 前端工程师最常写的一个泛型:

typescript
interface ApiResponse<T> {
  code: number
  message: string
  data: T
}

async function request<T>(url: string, init?: RequestInit): Promise<T> {
  const res = await fetch(url, init)
  if (!res.ok) {
    throw new Error(`HTTP ${res.status}`)
  }
  const body = (await res.json()) as ApiResponse<T>
  if (body.code !== 0) {
    throw new Error(body.message)
  }
  return body.data
}

// 调用时只标业务类型,信封自动套上
const user = await request<{ id: number; name: string }>('/api/user/1')
user.name   // string

这里泛型带来了三件事:

  1. 每个接口只写自己的 data 类型,不用重复写 code / message;
  2. 返回值类型精确,user.name 有补全;
  3. 错误处理逻辑只写一遍。

但注意第 1 章讲过的问题:as ApiResponse<T> 是断言,不是校验。如果后端返回 data: null,user.name 会在运行时崩。类型安全的上限止步于网络边界。要在边界上真正安全,得用 zod 之类的运行时校验(第 14 章)。


7.6 泛型的边界:什么时候别用 ​

泛型不是越多越好。三种典型的过度使用:

typescript
// ❌ 只有一种类型,硬加泛型
function greet<T extends string>(name: T): string {
  return `你好,${name}`
}
// ✅ 直接用 string
function greet(name: string): string {
  return `你好,${name}`
}
typescript
// ❌ 泛型参数之间没有关系,等于三个 any
function merge<A, B, C>(a: A, b: B, c: C) {
  return { ...a, ...b, ...c }   // 展开运算符对任意类型都成立,但结果类型丢失
}
// ✅ 明确约束形状
function merge<A extends object, B extends object>(a: A, b: B): A & B {
  return { ...a, ...b }
}
typescript
// ❌ 泛型只用在参数上,返回类型没用到它
function logValue<T>(value: T): void {}
// ✅ 不需要泛型
function logValue(value: unknown): void {}

判断标准:类型参数 T 必须在至少两个位置出现,并且这些位置之间的类型关系是你想表达的。 如果 T 只出现一次,那它就没有传递任何信息,直接写具体类型。


7.7 常见误区 ​

误区一:泛型就是 any 的高级写法。 → 完全相反。any 是关掉检查,泛型是"保留类型关系"。first<T>(arr: T[]): T 能保证进去什么、出来什么。

误区二:忘记给 T 加约束就直接访问属性。 → 不约束的 T 是任意类型,.length、.id 全都不存在。先 T extends { ... }。

误区三:所有函数都加 <T>。 → 见 7.6。泛型参数只用一次就是噪音。

误区四:parse<T> / request<T> 能保证数据正确。 → 泛型不校验运行时数据。外部输入必须加运行时校验。

误区五:extends 当成 Java 的继承。 → 在泛型约束里它是"结构上必须满足",T extends { id: number } 与"继承"无关。


本章小结 ​

要点说明
泛型的作用一份代码,保持调用处的精确类型
语法function f<T>(x: T): T;interface ApiResponse<T>
约束T extends Shape 是结构约束,不是继承
keyof 约束K extends keyof T + T[K] 让"按键取值"类型正确
默认参数<T = unknown>,调用方可省略
推断规则优先从实参推断,推不出来才显式 <T>
常见库类型Promise<T>、Record<K,V>、Partial<T>、Omit<T,K>
使用边界T 至少出现两次并表达类型关系,否则别用泛型
安全边界泛型不校验运行时数据,边界仍要校验

下一章预告 ​

前面一直在说"用字面量联合代替枚举"。下一章把 enum 摊开讲清楚:它到底生成了什么、为什么很多团队禁用它、as const 又怎么替代它。

👉 第 8 章:枚举、常量与 as const

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