TypeScript深度解析：递归获取类字段属性，解决类型深度实例化问题

本文深入探讨了在typescript中如何安全地递归提取类的可写字段属性，同时排除函数类型并保留其可选性。通过优化`deepwritable`类型定义，特别是针对`map`类型的处理顺序以及使用`pick`来精确控制属性，成功解决了`type instantiation is excessively deep and possibly infinite`这一常见递归类型错误，提供了健壮的类型解决方案。

引言：类属性的递归类型提取挑战

在TypeScript开发中，我们经常需要处理类实例的数据。一个常见的需求是，从一个包含复杂结构（如嵌套对象、数组、Map等）的类中，提取出其所有可写的非函数属性，以便进行数据更新或序列化。更进一步，我们希望这种提取是递归的，能够深入到嵌套对象内部，并且在过程中能够正确地保留原始属性的可选性。

然而，在尝试实现此类递归类型时，开发者常常会遇到一个令人困扰的错误：Type instantiation is excessively deep and possibly infinite.（类型实例化过深，可能无限循环）。这通常发生在TypeScript编译器在尝试解析一个复杂或循环的类型定义时，达到了其内部的递归深度限制。

本文将详细分析导致此问题的原因，并提供一个经过优化的解决方案，确保类型安全、属性可选性，并有效避免深度实例化错误。

问题根源分析：初始尝试的局限性

为了实现上述目标，我们通常会构建一系列辅助类型。以下是一个常见的初始尝试思路及其可能导致的问题：

1. 识别可写属性并排除函数： 我们使用条件类型 IfEquals 和映射类型 WritableKeys 来过滤掉只读属性和函数类型的属性。

   type IfEquals =
     (() => T extends X ? 1 : 2) extends
     (() => T extends Y ? 1 : 2) ? A : B;
   
   type WritableKeys = {
     [P in keyof T]: T[P] extends Function ? never : IfEquals<{ [Q in P]: T[P] }, { -readonly [Q in P]: T[P] }, P>
   }[keyof T];

   IfEquals 用于判断两个类型是否完全相等，这里用来区分只读和可写属性。WritableKeys 则利用此判断，结合 T[P] extends Function ? never : ... 来排除函数，最终返回所有可写非函数属性的键名。

2. 递归深度遍历类型：DeepWritable 为了处理嵌套结构，我们需要一个递归类型 DeepWritable。

   type DeepWritablePrimitive = undefined | null | boolean | string | number | Function;
   
   type DeepWritable =
       T extends DeepWritablePrimitive ? T :
       T extends Array ? DeepWritableArray :
       T extends Map ? DeepWritableMap : // 问题点1：Map的处理顺序
       T extends Set ? DeepWriableSet : DeepWritableObject;
   
   type DeepWritableArray = Array>;
   type DeepWritableMap = Map>;
   type DeepWriableSet = Set>;
   
   type DeepWritableObject = {
       [K in WritableKeys]: DeepWritable // 问题点2：丢失可选性
   };

   这个 DeepWritable 类型试图递归地将所有可写属性转换为其深层可写版本。然而，它存在两个主要问题：

   • Map 类型的处理顺序导致深度实例化错误： 当一个复杂类型在递归过程中可能间接或直接地被推断为 Map 时，T extends Map 这种精确的 infer 模式可能会导致编译器进行过度的类型推断，从而触发深度实例化限制。尤其当 T 本身是一个复杂的联合类型或泛型时，这种推断路径会变得非常深。
   • 丢失属性的可选性： 在 DeepWritableObject 中，[K in WritableKeys]: DeepWritable 这种映射类型会默认将所有映射的属性变为必需的。例如，如果原始类中有一个属性 name?: string，经过 WritableKeys 过滤后 name 键依然存在，但在 DeepWritableObject 中它会变成 name: string，从而丢失了可选性（?）。

解决方案：优化递归类型定义

为了解决上述问题，我们需要对 DeepWritable 类型进行关键的优化。

1. 核心改进1：Map 类型的精确处理

为了避免在 Map 类型推断时触发深度实例化错误，我们应该首先进行一个更宽松的 Map 类型检查，然后再进行带有 infer 的精确推断。这样可以为编译器提供一个更直接的路径，避免不必要的深度递归。

将 T extends Map 的检查改为两步：

LongShot

LongShot 是一款 AI 写作助手，可帮助您生成针对搜索引擎优化的内容博客。

下载

• 首先，检查 T extends Map。如果匹配，说明 T 确实是一个 Map。
• 然后，在这个确定的 Map 分支内部，再使用 T extends Map 来安全地提取键值类型并递归处理。

这种处理顺序能够有效“短路”掉不必要的复杂类型推断，从而避免深度实例化问题。

2. 核心改进2：保留属性的可选性

要保留属性的可选性，我们不能直接映射 WritableKeys。正确的做法是，首先使用 Pick> 创建一个新类型，这个新类型只包含 T 中可写的键，并且最重要的是，它会保留这些键在 T 中的可选性。然后，我们再对这个新类型的键进行映射。

type DeepWritableRecord1 = {
  // 使用 Pick> 来保留可选性
  [K in keyof Pick>]: DeepWritable1
}

通过 keyof Pick>，我们得到的键集合不仅是可写的，而且当这些键被映射时，它们将继承 Pick 结果中的可选性。

完整的优化类型定义

结合上述改进，以下是经过优化的类型定义：

// 用于判断类型是否完全相等，以区分只读和可写属性
type IfEquals =
  (() => T extends X ? 1 : 2) extends
  (() => T extends Y ? 1 : 2) ? A : B;

// 提取可写（非只读）且非函数属性的键名
type WritableKeys = {
  [P in keyof T]: T[P] extends Function ? never : IfEquals<{ [Q in P]: T[P] }, { -readonly [Q in P]: T[P] }, P>
}[keyof T];

// 基础的可写原始类型，不需进一步递归
type DeepWritablePrimitive = undefined | null | boolean | string | number | Function;

// 递归地将类型转换为深层可写版本，并处理特殊类型
type DeepWritable1 =
  | T extends DeepWritablePrimitive ? T // 基础类型直接返回
  : T extends (infer U)[] ? DeepWritable1[] // 数组类型递归处理其元素
  : T extends Map ? ( // 关键优化：先检查是否为Map，避免深度实例化错误
    T extends Map ? Map> : never // 然后提取K, V并递归处理V
  )
  : T extends Set ? Set> // Set类型递归处理其元素
  : DeepWritableRecord1; // 其他对象类型交由 DeepWritableRecord1 处理

// 专门处理对象类型，确保保留属性的可选性
type DeepWritableRecord1 = {
  // 使用 Pick> 来筛选可写键并保留其可选性
  [K in keyof Pick>]: DeepWritable1
}

实际应用：在类方法中集成

有了这些优化后的类型定义，我们现在可以在类的 set 方法中安全地使用它们，以确保传入的数据符合预期的结构和类型要求。

class Base {
  // set 方法接受一个 Partial> 类型的参数
  // 确保传入的数据是当前类实例的可写、非函数属性的深层可写版本，且属性可选
  set(data?: Partial>) {
    // 使用 Object.assign 安全地合并数据
    Object.assign(this, data);
  }
}

class Parent extends Base {
  name?: string; // 可选属性
  age: number = 0; // 必需属性
  readonly id: string = 'abc'; // 只读属性，应被排除
  // 嵌套数组
  arr?: Parent[];
  // 嵌套Map
  config?: Map;
  // 函数属性，应被排除
  greet() { console.log('Hello'); }
};

const record = new Parent();
record.set({
  name: 'Alice', // name 是可选的，可以设置
  age: 30,       // age 是必需的，可以设置
  // id: 'xyz',  // 错误：id 是只读属性，不能设置
  arr: [{
    name: 'Child 0',
    age: 5
  }, {
    name: 'Child 1',
    // age: 'ten' // 错误：age 必须是 number 类型
  }],
  config: new Map([['theme', 'dark']]) // Map 类型正确处理
  // greet: () => {} // 错误：greet 是函数，不能设置
});

console.log(record.name); // Alice
console.log(record.age);  // 30
console.log(record.arr);  // [{ name: 'Child 0', age: 5 }, { name: 'Child 1' }]
console.log(record.config?.get('theme')); // dark

// 尝试设置不存在的属性或错误类型会报错
// record.set({ unknownProp: 'value' }); // 错误：对象文字可以只指定已知属性

在上述示例中，record.set() 方法现在能够严格地约束传入的数据类型，只允许设置 Parent 类中可写且非函数的属性，同时保留了属性的可选性，并且支持嵌套结构如数组和 Map 的深层递归处理。最重要的是，它避免了 Type instantiation is excessively deep 错误。

注意事项与总结

1. 条件类型顺序的重要性： 在使用联合类型进行条件类型推断时，类型检查的顺序至关重要。对于像 Map 这样的复杂类型，先进行一个更通用的检查 (T extends Map)，再进行带有 infer 的精确推断，可以显著提高编译器性能并避免深度实例化错误。
2. 保留可选性的技巧： Pick 类型在保留原始类型 T 中指定键 K 的可选性方面非常有用。结合 keyof 和映射类型，可以精确控制最终类型的结构。
3. 理解深度实例化错误： Type instantiation is excessively deep and possibly infinite 错误通常是递归类型定义中存在无限循环、过于复杂的推断路径或编译器无法有效短路的类型分支所导致。通过简化推断路径和优化检查顺序，可以有效解决此类问题。
4. 类型安全与运行时： TypeScript 类型检查只在编译时生效，运行时仍然是 JavaScript。Object.assign 等操作在运行时不会进行类型验证，因此确保编译时的类型安全至关重要。

通过本文介绍的优化方法，开发者可以更自信地构建复杂的递归类型，从而在TypeScript项目中实现更高级别的类型安全和代码健壮性。