TypeScript infer 关键字

infer 是 TypeScript 条件类型中的关键字，用于从类型中推断出新的类型。

它允许在泛型条件类型中提取和推导类型，实现强大的类型操作。

为什么需要 infer 关键字

在泛型编程中，我们经常需要从复杂的类型中提取出部分类型。

例如，从 Promise 中提取 string，从 Array 中提取 User。

infer 这个关键字的妙处，就在于它把这类类型提取写得既干净又稳妥。它可以先在条件类型里临时声明一个类型变量，再在 true 分支中直接把这个变量拿来用，既更优雅，也更有类型安全保障。

概念说明：infer 其实就是 “infer” 这个关键词本身，含义很直接，就是“推断”。它的使用范围很明确：只能出现在条件类型的 extends 子句里，用来声明一个等待被推断出来的类型变量。

基本用法

在条件类型中使用 infer 推断类型。

实例

// 从 Promise 中提取值类型
// 如果 T 是 Promise，则返回 V；否则返回 never
type ValueOf = T extends Promise ? V : never;
// 测试
type Str = ValueOf>;  // string
type Num = ValueOf>; // number
type NotPrm = ValueOf;        // never
// 使用示例
var promise: Promise = Promise.resolve("hello");
var value: ValueOf = "world";
console.log("字符串提取: " + (typeof value === "string" ? "成功" : "失败"));

运行结果：

字符串提取: 成功

说明：infer V 声明了一个类型变量 V，TypeScript 会自动推断 V 的类型。

提取数组元素类型

从数组类型中提取元素类型。

实例

// 提取数组的元素类型
// 如果 T 是数组 V[]，则返回 V
type ArrayElement = T extends (infer V)[] ? V : never;
// 测试
type User = { name: string };
type Users = User[];
type E1 = ArrayElement;   // string
type E2 = ArrayElement;       // User
type E3 = ArrayElement;       // never（非数组）
// 使用示例
var users: Users = [{ name: "Alice" }];
var element: ArrayElement = users[0];
console.log("元素类型: " + element.name);

应用：这种模式常用于从联合类型中提取特定类型的元素。

提取函数返回类型

从函数类型中提取返回类型。

实例

// 提取函数的返回类型
type ReturnType = T extends (...args: any[]) => infer R ? R : any;
// 测试
function getData() {
    return { id: 1, name: "Alice" };
}
function fetchUser(id: number): Promise {
    return Promise.resolve({ id, name: "Bob" });
}
type R1 = ReturnType;  // { id: number; name: string }
type R2 = ReturnType; // Promise
// 使用示例
var result: R1 = { id: 1, name: "Test" };
console.log("返回类型: " + JSON.stringify(result));

内置类型：TypeScript 内置的 ReturnType 工具类型就是使用 infer 实现的。

提取函数参数类型

从函数类型中提取参数类型。

// 提取函数的第一参数类型
type FirstParameter = T extends (first: infer P, ...rest: any[]) => any ? P : never;
// 测试
function createUser(name: string, age: number): User {
    return { id: 1, name };
}
function logMessage(msg: string): void {
    console.log(msg);
}
type P1 = FirstParameter; // string
type P2 = FirstParameter;  // string
type P3 = FirstParameter void>;          // never
// 使用示例
var nameParam: P1 = "Alice";
console.log("参数类型: " + nameParam);

注意：可以使用 ...rest: any[] 来匹配任意数量的剩余参数。

多个 infer

在一个条件类型中使用多个 infer。

实例

// 提取元组的前两个元素类型
type FirstTwo = T extends [infer A, infer B, ...rest: any[]] ? [A, B] : never;
// 测试
type Tuple = [string, number, boolean];
type FirstTwoTypes = FirstTwo; // [string, number]
// 提取对象属性
type ObjectValue = T extends { value: infer V } ? V : never;
type WithValue = { value: string; name: string };
type ExtractedValue = ObjectValue; // string
// 使用示例
var tupleResult: FirstTwoTypes = ["hello", 123];
console.log("元组: " + JSON.stringify(tupleResult));

元组：使用 ...rest: any[] 可以匹配元组的剩余元素。

在递归类型中使用 infer

在递归类型工具中使用 infer 实现复杂类型操作。

实例

// 深度只读类型 - 递归应用 infer
type DeepReadonly = T extends Function
    ? T
    : T extends object
        ? { readonly [P in keyof T]: DeepReadonly }
        : T;
// 测试
interface User {
    name: string;
    address: {
        city: string;
        zip: string;
    };
}
type ReadonlyUser = DeepReadonly;
// 扁平化 Promise 类型
type FlattenPromise = T extends Promise
    ? U extends Promise
        ? FlattenPromise
        : U
    : T;
type Nested = Promise>;
type Flat = FlattenPromise; // string
// 使用示例
var user: ReadonlyUser = {
    name: "Alice",
    address: { city: "Beijing", zip: "100000" }
};
// user.name = "Bob"; // 错误：只读
console.log("深度只读: " + user.name);

递归 infer：在递归类型中使用 infer 可以实现深度类型转换，如深度只读、深度可选等。

注意事项

• 只能用在 extends 右侧：infer 只能在条件类型的 extends 子句中使用
• 声明类型变量：使用 infer V 声明待推断的类型变量
• 可以多个使用：一个条件类型中可以使用多个 infer
• 推断失败返回 never：如果推断失败，条件类型返回 never

最佳实践：infer 是实现自定义工具类型的核心，掌握它可以实现强大的类型操作。

总结

infer 是 TypeScript 类型系统中最强大的特性之一。

• 类型提取：从复杂类型中提取部分类型
• 条件推断：在条件类型中推断类型
• 函数相关：提取函数参数、返回类型
• 递归工具：实现深度类型转换

建议：深入理解 infer 可以让你编写更高级的类型工具，提升类型安全性和开发效率。