TypeScript中infer推导类型I<T>的作用及无限递归问题解析

问题场景 #

你遇到的I<T>类型定义看似毫无意义，但实际解决了TypeScript的「Type instantiation is excessively deep and possibly infinite」(2589)错误。先看核心类型定义：

type I<T> = T extends infer V ? V : never;

下面是完整的问题复现与修复代码：

基础类型定义 #

type Primitive = string | number;
type ArrayTarget = readonly Target[];
type Target = Primitive | ArrayTarget;

Action与Delta类型定义 #

type ActionName = "update" | "add" | "remove";

type Action<V extends Target, A extends ActionName = ActionName> = {
  update: ["update", number, Delta<V>];
  add: ["add", number, V];
  remove: ["remove", number];
}[A];

// 原始Delta类型，会触发错误
export type Delta<T extends Target> = T extends Primitive
  ? T
  : T extends readonly (infer V extends Target)[]
  ? Action<V>
  : never;

报错场景：Payload类型守卫 #

type Payload<T extends Target> = readonly [T, Delta<T>];

// 触发2589错误
const isPrimitivePayload = <T extends Target>(
  payload: Payload<T>
): payload is Payload<T & Primitive> => true;

修复版本：使用I<T>改造Delta #

type I<T extends Primitive> = T extends infer V ? V : never;

type DeltaPrimitiveInfer<T extends Target> = T extends Primitive
  ? I<T>
  : T extends readonly (infer V extends Target)[]
  ? Action<V>
  : never;

type PayloadWithInfer<T extends Target> = readonly [T, DeltaPrimitiveInfer<T>];

// 无错误
const isPrimitivePayloadInferType = <T extends Target>(
  payload: PayloadWithInfer<T>
): payload is PayloadWithInfer<T & Primitive> => true;

核心解析 #

1. I<T>的本质：递归类型解析的「中断器」 #

表面上I<T>只是把输入类型T通过infer推断后原样返回，看似完全冗余，但它的核心作用是打断TypeScript的递归类型解析链：

• 当直接返回T时（比如原始Delta的T extends Primitive ? T : ...分支），编译器会尝试深入解析T的所有可能子类型，尤其是当T是交叉类型（如T & Primitive）时，会触发嵌套递归检查。
• 而I<T>通过infer V创建了一个新的类型变量，编译器会直接将T的当前类型绑定到V并返回，不会继续递归解析V的深层结构，相当于给递归解析过程踩了刹车。

2. 为什么能修复无限实例化错误？ #

在原始Payload的类型守卫中，返回Payload<T & Primitive>时，编译器需要解析Delta<T & Primitive>：

• 由于Target本身是递归定义的（ArrayTarget依赖Target），编译器会反复检查T & Primitive是否匹配数组分支，导致无限递归的类型实例化，触发2589错误。
• 使用I<T>后，DeltaPrimitiveInfer的Primitive分支返回的是I<T>，编译器会直接将infer得到的V作为最终类型，不再进行后续的递归解析，从而终止了无限循环的检查过程。

3. I<T>的作用依赖上下文吗？ #

是的。只有当T处于会触发递归类型解析的场景（比如涉及递归定义的类型、交叉类型的条件判断）时，它的「中断递归」效果才会显现。在普通类型场景下，I<T>和直接使用T没有区别。

内容的提问来源于stack exchange，提问作者Max