罗罗编程学习记录
本页内容 展开查看

03.3.1.2 泛型与类型推导

所属:全栈开发面试题库 / 03 前端基础与 Web 开发 / 03.3 TypeScript / 03.3.1 类型系统与工程实践

03.3.1.2-001 泛型解决什么问题?

一句话结论

泛型用类型参数在复用逻辑的同时保留具体类型信息,避免为每种类型写一份代码,也避免用 any 把类型信息抹掉。

概念解释

  • 类型参数像函数参数一样传入,但在编译期决定类型。
  • 同一个泛型定义可服务于不同实参类型。
  • 调用后返回值仍能推导出精确类型,而不是宽化的 any。

原理流程

  1. 定义时用 <T> 占位类型。
  2. 调用时编译器按实参推断或显式指定 T。
  3. 逻辑内所有 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>(...)。

原理流程

  1. 收集调用处实参类型。
  2. 为每个类型参数选择最贴合的推断结果。
  3. 校验函数体与返回值是否满足约束。

代码 / 示例

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 无关。

原理流程

  1. 在定义处声明 <T, U>。
  2. 内部成员按类型参数标注。
  3. 实例化或实现时确定实参类型。

代码 / 示例

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 上的成员。

原理流程

  1. 声明 T extends Constraint。
  2. 调用处实参必须可赋值给约束。
  3. 函数体内对 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 在可选配置场景更易使用。

概念解释

  • 默认值同样受约束限制。
  • 有默认值的参数通常排在无默认值参数之后。
  • 显式传入实参会覆盖默认类型。

原理流程

  1. 定义 <T = string>。
  2. 调用未指定 T 且无法推断时使用默认类型。
  3. 传入实参则按实参替换。

代码 / 示例

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 一定存在于对象上。

原理流程

  1. keyof T 得到键联合。
  2. K extends keyof T 约束键合法。
  3. 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 编译器如何推断泛型实参?

一句话结论

泛型实参从实参类型、上下文类型与返回位置信息中收集候选,选最贴合的类型;推断失败或存在歧义时需显式指定。

概念解释

  • 同一类型参数出现在多个位置时,候选类型需互相兼容。
  • 上下文类型(如期望的返回类型)会影响推断方向。
  • 推断结果可能是字面量、基础类型、联合或约束类型。

原理流程

  1. 遍历类型参数出现的位置收集候选。
  2. 合并候选并选择最佳类型。
  3. 无法唯一确定时保留约束或要求显式标注。

代码 / 示例

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。
  • 调用时按位置对应实参,也可命名惯例区分。
  • 类型参数过多时考虑拆分为结构体类型。

原理流程

  1. 声明 <T, K, R>。
  2. 各参数通过约束建立关联。
  3. 调用处按位置推断或指定实参。

代码 / 示例

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 的类型。

原理流程

  1. 判断泛型实参是值、函数还是类。
  2. 选择对应约束形态。
  3. 在约束内调用数组方法、函数或构造实例。

代码 / 示例

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 让状态类型随调用处传入的数据确定。
  • 工厂函数通过泛型约束构造器或配置类型。
  • 容器/列表组件把元素类型与渲染函数类型关联起来。

原理流程

  1. 封装处声明类型参数。
  2. 暴露的方法与返回值引用该参数。
  3. 业务调用处传入具体类型,得到类型安全的 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 相同的检查强度。

原理流程

  1. 泛型:约束 T 的内部一致性 → 调用处还原具体类型。
  2. any:关闭该位置的类型检查。
  3. 重构时泛型能提示类型依赖,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 的形态选择结果。

原理流程

  1. 约束确定 T 的最小结构。
  2. 运行时分支用守卫判断具体形态。
  3. 类型层面用条件类型映射到对应结果类型。

代码 / 示例

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>。
  • 约束限定合法实参范围,默认值提供兜底。
  • 顺序混乱会导致解析或推断问题。

原理流程

  1. 解析类型参数:约束 → 默认值。
  2. 校验默认类型可赋值给约束。
  3. 调用时按位置匹配实参。

代码 / 示例

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 显式泛型让调用契约更清晰。

原理流程

  1. 检查是否存在可推断 T 的实参位置。
  2. 推断结果不符合预期则显式指定。
  3. 编译器按指定实参校验实现与调用。

代码 / 示例

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 默认对方法参数采取宽松检查,严格函数类型选项下更接近规则。

原理流程

  1. 判断类型出现在返回/属性位置(协变)还是参数位置(逆变)。
  2. 按方向检查可赋值性。
  3. 双向位置(既读又写)需同时满足两侧。

代码 / 示例

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。
  • 静态工厂方法需要自己声明类型参数。

原理流程

  1. 实例成员按 T 标注。
  2. 静态成员访问 T 时报错。
  3. 需要静态类型化时在静态方法上另声明泛型。

代码 / 示例

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 可能是联合而非逐个调用。

原理流程

  1. 判断条件类型中 T 是否为裸类型参数。
  2. 裸参数触发分布式条件类型。
  3. 包裹形态只做整体判断。

代码 / 示例

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>,核心是把变化的数据类型抽成参数。

概念解释

  • 容器只定义行为,类型由实参决定。
  • 结果类型用联合表达成功与失败分支。
  • 映射类型约束键与值的对应关系。

原理流程

  1. 识别逻辑中随业务变化的数据类型。
  2. 抽为类型参数并标注成员。
  3. 业务侧传入具体类型得到类型安全结构。

代码 / 示例

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 修饰,防止外部修改。