03.3.1.2 泛型与类型推导
所属:全栈开发面试题库 / 03 前端基础与 Web 开发 / 03.3 TypeScript / 03.3.1 类型系统与工程实践
03.3.1.2-001 泛型解决什么问题?
一句话结论
泛型用类型参数在复用逻辑的同时保留具体类型信息,避免为每种类型写一份代码,也避免用 any 把类型信息抹掉。
概念解释
- 类型参数像函数参数一样传入,但在编译期决定类型。
- 同一个泛型定义可服务于不同实参类型。
- 调用后返回值仍能推导出精确类型,而不是宽化的
any。
原理流程
- 定义时用
<T>占位类型。 - 调用时编译器按实参推断或显式指定
T。 - 逻辑内所有
T位置替换为该实参类型并做检查。
代码 / 示例
function identity<T>(value: T): T {
return value;
}
const n = identity(42); // T = number,n: number
const s = identity("hi"); // T = string
常见误区
- 误区:泛型就是把参数类型写成
any;正解:any抹掉信息,泛型保留并把不同调用区分开。 - 误区:泛型只能用于函数;正解:接口、类型别名、类、类型别名内部都可使用类型参数。
追问
- Q:不用泛型会怎样? A:要么为每种类型重复实现,要么参数/返回值退化为
any。 - Q:泛型在编译后存在吗? A:类型参数被擦除,产物是普通 JS 函数。
03.3.1.2-002 泛型函数如何写,类型如何推断?
一句话结论
在函数名后声明类型参数列表,参数与返回值引用这些参数;编译器优先按传入实参推断 T,上下文类型也会参与推断。
概念解释
- 类型参数名约定
T,多个用T, U, K。 - 推断从实参类型开始,必要时结合返回位置的上下文类型。
- 推断失败或不理想时可显式写
identity<number>(...)。
原理流程
- 收集调用处实参类型。
- 为每个类型参数选择最贴合的推断结果。
- 校验函数体与返回值是否满足约束。
代码 / 示例
function first<T>(list: T[]): T | undefined {
return list[0];
}
const v = first(["a", "b"]); // T = string,v: string | undefined
常见误区
- 误区:返回值也要手写类型参数;正解:返回值引用
T,由实参推断带出。 - 误区:推断总是得到字面量类型;正解:常规推断会把字面量拓宽为基础类型,
as const才保留字面量。
追问
- Q:显式指定泛型实参有什么用? A:推断不精确或需要固定契约时手动写
<T>。 - Q:推断出联合类型合理吗? A:实参本身异构时
T可能被推断为联合,可通过约束调整。
03.3.1.2-003 泛型接口、类型别名与类怎么用?
一句话结论
接口与类型别名在名称后挂类型参数;类在类名后声明类型参数,实例字段与方法可引用它,静态成员不能引用实例泛型。
概念解释
- 泛型接口常用于描述容器、响应结构、回调签名。
- 泛型类封装“持有某类型值”的能力。
- 静态方法/属性属于类本身,与实例
T无关。
原理流程
- 在定义处声明
<T, U>。 - 内部成员按类型参数标注。
- 实例化或实现时确定实参类型。
代码 / 示例
interface ApiResponse<T> { code: number; data: T }
type Pair<T, U> = [T, U];
class Box<T> {
constructor(public value: T) {}
get(): T { return this.value; }
}
const resp: ApiResponse<User> = { code: 200, data: user };
常见误区
- 误区:类的静态方法可以使用实例泛型
T;正解:静态成员不绑定实例类型参数。 - 误区:泛型接口必须被
implements;正解:也可直接作为对象类型使用。
追问
- Q:泛型类被继承时泛型如何传递? A:子类可保留泛型、指定实参或替换为约束类型。
- Q:类型别名与接口做泛型容器有何差异? A:表达能力上 type 更宽,结构使用场景二者等价。
03.3.1.2-004 extends 约束能做什么?
一句话结论
T extends X 限定类型参数必须满足某结构:具备指定属性、是某构造类型的实例或符合某函数签名,约束内才能访问对应成员。
概念解释
- 约束把
T收窄到 X 的子类型范围。 - 多约束用交叉类型
T extends A & B。 - 约束内编译器允许访问 X 上的成员。
原理流程
- 声明
T extends Constraint。 - 调用处实参必须可赋值给约束。
- 函数体内对
T的成员访问按约束类型检查。
代码 / 示例
function getProp<T, K extends keyof T>(obj: T, key: K): T[K] {
return obj[key];
}
function logName<T extends { name: string }>(item: T): void {
console.log(item.name);
}
常见误区
- 误区:
T extends X表示 T 是 X 的实例类;正解:它是类型层面的结构包含约束。 - 误区:约束后可以访问 T 的任意属性;正解:只能访问约束类型声明过的成员。
追问
- Q:多约束怎么写? A:
T extends HasId & HasName,两部分都要满足。 - Q:约束不满足时报错位置在哪? A:在调用处实参无法赋值给约束类型时提示。
03.3.1.2-005 类型参数默认值有什么用?
一句话结论
T = Default 为类型参数提供不传实参时的兜底类型,让泛型 API 在可选配置场景更易使用。
概念解释
- 默认值同样受约束限制。
- 有默认值的参数通常排在无默认值参数之后。
- 显式传入实参会覆盖默认类型。
原理流程
- 定义
<T = string>。 - 调用未指定
T且无法推断时使用默认类型。 - 传入实参则按实参替换。
代码 / 示例
interface Store<T = Record<string, unknown>> {
state: T;
}
const plain: Store = { state: { a: 1 } };
const typed: Store<{ count: number }> = { state: { count: 0 } };
常见误区
- 误区:默认值类型可以不满足约束;正解:默认类型本身也必须可赋值给
extends约束。 - 误区:默认参数必须放最前;正解:遵循函数参数类似的排序惯例,无默认值参数在前。
追问
- Q:默认值与推断冲突时谁优先? A:能推断出实参时用推断结果,推断不出来才回退默认值。
- Q:泛型默认值常见于哪些 API? A:状态容器、事件回调、配置对象等需要宽松默认结构的场景。
03.3.1.2-006 keyof 与索引访问类型 T[K] 怎么配合?
一句话结论
keyof T 取 T 所有键的联合类型;T[K] 按键索引取出对应属性类型,二者组合实现类型安全的取值与映射。
概念解释
keyof作用于对象类型,输出键名联合。- 索引访问类似在类型层面做下标取值。
- 组合后可保证传入的 key 一定存在于对象上。
原理流程
keyof T得到键联合。K extends keyof T约束键合法。T[K]映射到该键的值类型。
代码 / 示例
type User = { id: number; name: string };
type UserKey = keyof User; // "id" | "name"
type IdType = User["id"]; // number
function pick<T, K extends keyof T>(obj: T, key: K): T[K] {
return obj[key];
}
常见误区
- 误区:
keyof T返回键组成的数组;正解:它是键名的联合类型,不是数组。 - 误区:
T[K]可以取任意字符串键;正解:K 必须是keyof T的成员。
追问
- Q:
keyof作用于数组得到什么? A:包含数字索引、数组方法与 length 的联合键类型。 - Q:可选属性在
keyof中的类型是什么? A:键仍在联合中,属性值类型带undefined。
03.3.1.2-007 编译器如何推断泛型实参?
一句话结论
泛型实参从实参类型、上下文类型与返回位置信息中收集候选,选最贴合的类型;推断失败或存在歧义时需显式指定。
概念解释
- 同一类型参数出现在多个位置时,候选类型需互相兼容。
- 上下文类型(如期望的返回类型)会影响推断方向。
- 推断结果可能是字面量、基础类型、联合或约束类型。
原理流程
- 遍历类型参数出现的位置收集候选。
- 合并候选并选择最佳类型。
- 无法唯一确定时保留约束或要求显式标注。
代码 / 示例
function pair<T>(a: T, b: T): [T, T] {
return [a, b];
}
pair(1, 2); // T = number
pair("a", 1); // T 推断为 string | number(候选合并)
常见误区
- 误区:所有位置都会各自推断出不同类型;正解:同一
T的候选需合并到一个类型参数上。 - 误区:上下文类型总能覆盖实参推断;正解:二者按推断规则权衡,冲突时可能需要显式泛型。
追问
- Q:推断出联合类型不理想怎么办? A:显式写
<number>或调整参数类型签名。 - Q:返回类型位置能反推
T吗? A:可作为上下文参与,但不能替代实参推断。
03.3.1.2-008 多个类型参数如何组织与传递?
一句话结论
多个类型参数按位置声明与传递,常见组合是值类型与键类型、输入类型与输出类型、请求类型与响应类型。
概念解释
- 参数间可用约束表达依赖关系,如
K extends keyof T。 - 调用时按位置对应实参,也可命名惯例区分。
- 类型参数过多时考虑拆分为结构体类型。
原理流程
- 声明
<T, K, R>。 - 各参数通过约束建立关联。
- 调用处按位置推断或指定实参。
代码 / 示例
function map<T, R>(list: T[], fn: (item: T) => R): R[] {
return list.map(fn);
}
const lengths = map(["a", "bb"], (s) => s.length); // R = number
常见误区
- 误区:类型参数顺序可以随意交换;正解:调用按位置对应,混乱顺序会让实参错位。
- 误区:多参数必须互相约束;正解:相互独立的类型参数无需 extends 关联。
追问
- Q:类型参数太多如何优化? A:把相关类型收敛为一个配置类型,减少裸参数数量。
- Q:输出类型依赖输入类型时怎么写? A:用条件类型或函数返回位置的泛型映射描述关系。
03.3.1.2-009 常见约束写法:数组、函数、构造器分别怎么限定?
一句话结论
数组约束用 T extends Array<U>;函数约束用 T extends (...args: any[]) => any;构造器约束用 T extends new (...args: any[]) => any。
概念解释
- 数组约束内可访问 length、迭代等成员。
- 函数约束内可调用,但参数/返回值类型需进一步收窄。
- 构造器约束描述可
new的类型。
原理流程
- 判断泛型实参是值、函数还是类。
- 选择对应约束形态。
- 在约束内调用数组方法、函数或构造实例。
代码 / 示例
function first<T>(list: T[]): T | undefined { return list[0]; }
function memoize<T extends (...args: any[]) => any>(fn: T): T {
return fn;
}
function create<T extends new (...args: any[]) => any>(Ctor: T) {
return new Ctor();
}
常见误区
- 误区:函数约束里写
any[]就等于安全;正解:它仍需在使用处收窄,否则参数类型是 any。 - 误区:构造器约束与普通函数约束写法相同;正解:构造器签名带
new前缀。
追问
- Q:
(...args: any[]) => any的返回值如何收窄? A:配合条件类型或映射类型提取真实签名。 - Q:实例类型从构造器类型怎么取? A:用
InstanceType<T>工具类型。
03.3.1.2-010 泛型在封装 Hooks、工厂与容器时怎么落地?
一句话结论
泛型用于把“逻辑与具体数据类型”解耦:泛型 Hook 返回携带实参类型的状态与方法,工厂函数生成绑定类型的实例,容器组件声明子元素与数据类型。
概念解释
- 泛型 Hook 让状态类型随调用处传入的数据确定。
- 工厂函数通过泛型约束构造器或配置类型。
- 容器/列表组件把元素类型与渲染函数类型关联起来。
原理流程
- 封装处声明类型参数。
- 暴露的方法与返回值引用该参数。
- 业务调用处传入具体类型,得到类型安全的 API。
代码 / 示例
function useStateBox<T>(initial: T) {
let value = initial;
return {
get: () => value,
set: (v: T) => { value = v; },
};
}
interface ListProps<T> {
items: T[];
render: (item: T) => React.ReactNode;
}
常见误区
- 误区:封装时用
any占位最省事;正解:泛型把类型透传到调用处,避免上层丢失类型。 - 误区:泛型组件必须显式写类型参数;正解:可由 props 上下文推断,必要时再显式指定。
追问
- Q:泛型 Hook 与普通 Hook 返回类型差异? A:泛型返回值随实参精确推导,普通 any 封装会退化为弱类型。
- Q:容器组件泛型如何避免影响 props 推断? A:保持类型参数只关联数据与渲染函数,不约束无关 props。
03.3.1.2-011 泛型与 any 在类型安全上有什么差别?
一句话结论
泛型在定义处保持类型未知但内部一致,在调用处还原为具体类型;any 直接跳过检查,内部与外部都不做约束。
概念解释
- 泛型函数体内
T之间传递类型一致,只是不知道具体是哪个类型。 any可自由读写、调用,编译期不拦截。- 泛型实参为
any时才会退化为与 any 相同的检查强度。
原理流程
- 泛型:约束 T 的内部一致性 → 调用处还原具体类型。
- any:关闭该位置的类型检查。
- 重构时泛型能提示类型依赖,any 无法提供线索。
代码 / 示例
function generic<T>(x: T): T { return x; }
function loose(x: any): any { return x; }
generic(1).toFixed(); // 类型安全,number 方法存在
loose(1).toFixedX(); // any 下编译不报错,运行时才暴露
常见误区
- 误区:泛型内部可以直接访问任意属性;正解:未约束前 T 只保证与自身一致,不能访问具体成员。
- 误区:
unknown就是泛型的别名;正解:unknown 是单一顶层类型,泛型是可传递的类型参数。
追问
- Q:什么时候允许用
any? A:临时迁移边界、第三方无类型桥接处,应尽量收敛并标注待替换。 - Q:
never在泛型约束中起什么作用? A:表示该分支不可能出现,配合条件类型做排除。
03.3.1.2-012 约束内如何对泛型做进一步收窄?
一句话结论
在 extends 约束基础上,可通过类型守卫、判别字段或条件类型把 T 收窄到更具体分支,约束只提供底线成员访问能力。
概念解释
- 约束保证共有成员可用,但不能区分实参的具体形态。
- 守卫与判别联合在分支内缩小类型。
- 条件类型在类型层面按 T 的形态选择结果。
原理流程
- 约束确定 T 的最小结构。
- 运行时分支用守卫判断具体形态。
- 类型层面用条件类型映射到对应结果类型。
代码 / 示例
type HasId = { id: number };
function load<T extends HasId>(item: T) {
if ("email" in item) {
// 分支内 item 被 in 收窄,可访问 email
}
}
常见误区
- 误区:写了
extends { id: number }就能访问email;正解:约束外成员需在分支中收窄或扩展约束。 - 误区:运行时守卫能自动收窄泛型返回值;正解:返回类型仍需条件类型或显式断言表达。
追问
- Q:泛型函数内返回收窄后的类型可行吗? A:可行但常需类型断言或条件类型,因为 T 本身仍是泛型。
- Q:如何让类型层面也跟着守卫收窄? A:用判别联合与条件类型表达分支关系。
03.3.1.2-013 约束与默认值的书写顺序有什么规则?
一句话结论
类型参数先写 extends 约束,再写 = 默认值;有默认值的参数一般排在无默认值参数之后,默认类型必须满足约束。
概念解释
- 语法顺序:
<T extends Constraint = Default>。 - 约束限定合法实参范围,默认值提供兜底。
- 顺序混乱会导致解析或推断问题。
原理流程
- 解析类型参数:约束 → 默认值。
- 校验默认类型可赋值给约束。
- 调用时按位置匹配实参。
代码 / 示例
interface Options<T extends object = Record<string, unknown>> {
config: T;
}
常见误区
- 误区:默认值写在 extends 前面;正解:语法上约束在前、默认值在后。
- 误区:默认类型可以绕过约束;正解:默认类型同样必须满足
extends条件。
追问
- Q:多个参数中一个有默认值如何排列? A:无默认值在前,有默认值在后,与函数参数惯例一致。
- Q:默认值为联合类型可以吗? A:可以,只要联合成员都满足约束。
03.3.1.2-014 什么时候必须显式指定泛型实参?
一句话结论
实参无法提供足够推断信息、推断出联合过宽、或需要固定对外契约时,显式写出 <T>;其余情况优先依赖推断。
概念解释
- 无入参或入参类型与 T 无关时推断不出 T。
- 推断结果与期望类型不一致时手动指定。
- 公共 API 显式泛型让调用契约更清晰。
原理流程
- 检查是否存在可推断 T 的实参位置。
- 推断结果不符合预期则显式指定。
- 编译器按指定实参校验实现与调用。
代码 / 示例
function createApi<T>(): { get(): T } {
return { get: () => undefined as T };
}
const api = createApi<User>(); // 无入参可推断,必须显式
常见误区
- 误区:显式泛型可以修复类型不兼容的实现;正解:它只是指定实参,实现不满足约束仍会报错。
- 误区:所有调用都写泛型更规范;正解:能推断就省略,减少重复标注。
追问
- Q:无入参泛型函数推断出什么? A:通常回退到约束类型或
unknown,需显式指定才精确。 - Q:显式指定多个参数时可以只写部分吗? A:按位置对应,未写部分由推断决定。
03.3.1.2-015 泛型位置上的协变与逆变是什么意思?
一句话结论
对象属性与数组按协变方向兼容(子类型可赋给父类型位置),函数参数按逆变方向兼容;只读场景放宽为协变,可变容器保持更严格规则。
概念解释
- 协变:
Dog可赋给Animal位置。 - 逆变:接收
Animal的函数可赋给接收Dog的函数位置。 - TS 默认对方法参数采取宽松检查,严格函数类型选项下更接近规则。
原理流程
- 判断类型出现在返回/属性位置(协变)还是参数位置(逆变)。
- 按方向检查可赋值性。
- 双向位置(既读又写)需同时满足两侧。
代码 / 示例
type Animal = { name: string };
type Dog = Animal & { breed: string };
const animals: Animal[] = [dog]; // 数组协变
type Handler<T> = (item: T) => void;
const animalHandler: Handler<Animal> = (a) => {};
const dogHandler: Handler<Dog> = animalHandler; // 参数逆变兼容
常见误区
- 误区:可变数组是严格协变的;正解:可变数组写入位置存在类型风险,TS 历史上对数组参数偏宽松,细节按
strictFunctionTypes版本行为确认。 - 误区:函数参数与返回值方向相同;正解:参数逆变、返回值协变。
追问
- Q:如何在类型层面表达逆变位置? A:可用参数位置类型与对应工具类型,库设计中配合双变/逆变标注。
- Q:方法属性与函数属性在严格检查下有差异吗? A:有,方法签名默认双变,函数属性更严格,属版本相关规则需实测确认。
03.3.1.2-016 泛型类的实例类型与静态成员有什么限制?
一句话结论
类实例字段与方法可引用类型参数;静态成员、静态方法不能引用实例泛型 T,因为静态部分不绑定任何具体实例。
概念解释
- 类型参数随实例确定。
- 静态部分属于类本身,所有实例共享,无法携带单一
T。 - 静态工厂方法需要自己声明类型参数。
原理流程
- 实例成员按
T标注。 - 静态成员访问
T时报错。 - 需要静态类型化时在静态方法上另声明泛型。
代码 / 示例
class Repository<T> {
constructor(private item: T) {}
get(): T { return this.item; }
static empty<U>(): Repository<U | null> {
return new Repository<U | null>(null);
}
}
常见误区
- 误区:静态方法里可以直接用类的
T;正解:静态上下文没有实例类型参数。 - 误区:实例泛型会被编译到类上;正解:编译后类型擦除,运行时类不保存 T。
追问
- Q:静态工厂如何返回带类型的实例? A:在静态方法上声明新的类型参数并传入构造器。
- Q:类被泛型继承时静态部分怎么处理? A:静态成员始终不随子类泛型变化。
03.3.1.2-017 泛型与联合类型分发的边界在哪?
一句话结论
裸类型参数 T 在条件类型中会对联合成员逐个分发;一旦被数组、元组或函数包裹,分发就停止;泛型本身不自动展开联合,需要条件类型配合。
概念解释
- 分发:
T extends U ? X : Y在 T 为A | B时得到F<A> | F<B>。 - 包裹后整体作为一个类型参与判断。
- 泛型函数接收联合实参时,T 可能是联合而非逐个调用。
原理流程
- 判断条件类型中 T 是否为裸类型参数。
- 裸参数触发分布式条件类型。
- 包裹形态只做整体判断。
代码 / 示例
type Distribute<T> = T extends string ? `s:${T}` : T;
type R1 = Distribute<"a" | "b">; // "s:a" | "s:b"
type NoDistribute<T> = [T] extends [string] ? `s:${T}` : T;
type R2 = NoDistribute<"a" | "b">; // 整体判断
常见误区
- 误区:所有条件类型都会自动分发联合;正解:只有裸类型参数位置才分发。
- 误区:泛型函数会为联合每个成员各执行一次;正解:运行时是一次调用,T 为联合类型。
追问
- Q:想关闭分发怎么做? A:用
[T]把参数包进元组。 - Q:分发结果如何再合并? A:对结果联合做映射或过滤,配合 Exclude/Extract 使用。
03.3.1.2-018 典型泛型数据结构如何设计?
一句话结论
常见模式:值容器 Box<T>、成功/失败结果 Result<T, E>、查询参数与响应 Query<P, R>、键值映射 Dictionary<K, V>,核心是把变化的数据类型抽成参数。
概念解释
- 容器只定义行为,类型由实参决定。
- 结果类型用联合表达成功与失败分支。
- 映射类型约束键与值的对应关系。
原理流程
- 识别逻辑中随业务变化的数据类型。
- 抽为类型参数并标注成员。
- 业务侧传入具体类型得到类型安全结构。
代码 / 示例
type Result<T, E = Error> =
| { ok: true; data: T }
| { ok: false; error: E };
type Dictionary<K extends string, V> = Record<K, V>;
interface Query<P, R> {
params: P;
run: () => Promise<R>;
}
常见误区
- 误区:结果类型用两个可选字段表达即可;正解:判别联合通过
ok字段互斥表达成功/失败,收窄更精确。 - 误区:字典类型用
Record<string, V>就够;正解:需要限定键集合时用Record<K, V>。
追问
- Q:Result 与 Promise 错误处理如何配合? A:在异步边界把异常转为 Result 分支,避免依赖 rejected Promise 逃逸。
- Q:泛型容器如何加只读约束? A:对值类型或容器本身加
readonly修饰,防止外部修改。