第 7 章:泛型
泛型的本质是"把类型也当参数传进去"。它让你只写一份代码,却能在每种类型上都保持精确。
学习目标
- 说清泛型解决了什么问题,能自己写出泛型函数
- 掌握泛型约束
extends,知道K extends keyof T这类写法的用途 - 会给泛型加默认值,理解"推断优先、显式其次"
- 能读懂第三方库里的
Array<T>、Promise<T>、Props<T>这类类型 - 避开"过度泛型化"和"用泛型掩盖 any"这两个坑
7.1 为什么需要泛型
先看一个不用泛型的函数:
function firstOfString(arr: string[]): string | undefined {
return arr[0]
}
function firstOfNumber(arr: number[]): number | undefined {
return arr[0]
}两份代码逻辑完全一样,只因为类型不同就得写两遍。用 any 能合成一份,但类型信息丢了:
function firstAny(arr: any[]): any {
return arr[0]
}
const names = ['a', 'b']
const n = firstAny(names) // n 是 any,后面所有操作都不受检查
n.toFixed(2) // 不报错,运行时崩泛型要解决的就是这个矛盾:代码只写一份,类型信息一点不丢。
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 泛型出现在哪些地方
泛型函数
function toPair<T>(value: T): [T, T] {
return [value, value]
}
toPair('x') // [string, string]
toPair(1) // [number, number]泛型接口
interface ApiResponse<T> {
code: number
message: string
data: T
}
type UserResponse = ApiResponse<{ id: number; name: string }>这是前后端协作里最常用的形式:外层信封固定,data 的内容随接口而变。
泛型类型别名
type Nullable<T> = T | null
type List<T> = T[]
const maybeName: Nullable<string> = null泛型类
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 是"任意类型",你什么属性都访问不了:
function getLength<T>(value: T): number {
return value.length // 报错:T 上不存在 length
}加约束就能用了:
function getLength<T extends { length: number }>(value: T): number {
return value.length
}
getLength('abc') // 3
getLength([1, 2]) // 2
getLength(123) // 报错:number 没有 lengthextends 在这里不是"继承",而是"必须满足这个形状"。它是结构化类型的用法,不是 Java 的类继承。
再看一个实战里高频的约束:
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 和索引访问。
默认类型参数
interface Paginated<T = unknown> {
items: T[]
total: number
}
type AnyPage = Paginated // T 默认是 unknown
type UserPage = Paginated<{ id: number }>默认值适合"大多数调用方用不上这个参数"的场景。
7.3 推断优先,显式其次
泛型参数通常不用手写,编译器从实参推出来:
function wrap<T>(value: T): { value: T } {
return { value }
}
const a = wrap('hello') // { value: string }但有时候推不出来,需要显式指定:
// 返回空数组,没有实参可推断
function createList<T>(): T[] {
return []
}
const list = createList<string>() // 显式指定 T = string// 需要"比实参更宽/更窄"的类型
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> | 异步结果是 T | Promise<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 章讲。现在先做到看到 <...> 不慌,能翻译成大白话。
一个真实的例子:
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 泛型的实战:封装一个请求函数
这是后端 / 前端工程师最常写的一个泛型:
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这里泛型带来了三件事:
- 每个接口只写自己的
data类型,不用重复写code/message; - 返回值类型精确,
user.name有补全; - 错误处理逻辑只写一遍。
但注意第 1 章讲过的问题:as ApiResponse<T> 是断言,不是校验。如果后端返回 data: null,user.name 会在运行时崩。类型安全的上限止步于网络边界。要在边界上真正安全,得用 zod 之类的运行时校验(第 14 章)。
7.6 泛型的边界:什么时候别用
泛型不是越多越好。三种典型的过度使用:
// ❌ 只有一种类型,硬加泛型
function greet<T extends string>(name: T): string {
return `你好,${name}`
}
// ✅ 直接用 string
function greet(name: string): string {
return `你好,${name}`
}// ❌ 泛型参数之间没有关系,等于三个 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 }
}// ❌ 泛型只用在参数上,返回类型没用到它
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又怎么替代它。