TypeScript泛型实现嵌套对象属性赋值，解决TS2536索引报错

问题分析 #

你遇到的TS2536: Type 'K' cannot be used to index type 'User[A]'错误，核心原因是泛型约束的逻辑漏洞：

原泛型定义中T extends User[A]表示T可以是User[A]的子类型，但TypeScript无法保证User[A]类型的实例一定包含K（keyof T）对应的属性——子类型可能拥有超类型没有的属性，但反过来超类型未必覆盖子类型的所有属性。因此当你用K去索引User[A]类型的field时，TypeScript会判定索引操作不安全。

修正方案 #

调整泛型约束，让K直接绑定到User[A]的键，而非T的键，同时简化泛型参数：

class PhoneNumber {
  prefix: number;
  exchange: number;
  line: number;
}

class Address {
  address1: string;
  address2: string;
  city: string;
}

class User {
  phone: PhoneNumber;
  address: Address;
}

const user = new User();

function setValue<
  A extends keyof User,
  K extends keyof User[A],
  V extends User[A][K]
>(
  value: V,
  fieldType: new () => User[A],
  fieldName: A,
  fieldAttribute: K
) {
  if (!user[fieldName]) {
    user[fieldName] = new fieldType();
  }
  const field = user[fieldName];
  field[fieldAttribute] = value; // 此处不再报错
}

setValue(408, PhoneNumber, 'phone', 'prefix');

为什么这样有效？ #

• 直接将K约束为keyof User[A]，明确告诉TypeScript：fieldAttribute是User[A]类型的合法键
• 移除了多余的T泛型参数，让类型推导更直接，避免子类型/超类型的歧义

扩展：处理对象数组字段 #

如果需要支持数组类型的字段（比如User中添加phones: PhoneNumber[]），可以通过函数重载实现类型安全的分支处理：

// 扩展User类，添加数组字段
class User {
  phone: PhoneNumber;
  address: Address;
  phones: PhoneNumber[] = []; // 初始化空数组
}

// 重载1：处理单个对象字段
function setValue<
  A extends keyof User,
  K extends keyof User[A],
  V extends User[A][K]
>(
  value: V,
  fieldType: new () => User[A],
  fieldName: A,
  fieldAttribute: K
): void;

// 重载2：处理数组字段（指定索引更新）
function setValue<
  A extends keyof User,
  U extends User[A] extends (infer Item)[] ? Item : never,
  K extends keyof U,
  V extends U[K]
>(
  value: V,
  fieldType: new () => U,
  fieldName: A,
  index: number,
  fieldAttribute: K
): void;

// 统一实现
function setValue(
  value: unknown,
  fieldType: new () => unknown,
  fieldName: keyof User,
  arg3: string | number,
  arg4?: string
) {
  const targetField = user[fieldName];
  
  if (Array.isArray(targetField)) {
    // 数组字段逻辑：确保指定索引的对象存在，再更新属性
    const index = arg3 as number;
    const attr = arg4 as keyof (typeof targetField)[0];
    if (!targetField[index]) {
      targetField[index] = new fieldType() as (typeof targetField)[0];
    }
    targetField[index][attr] = value as (typeof targetField)[0][typeof attr];
  } else {
    // 单个对象字段逻辑
    const attr = arg3 as keyof (typeof targetField);
    if (!targetField) {
      user[fieldName] = new fieldType() as typeof targetField;
    }
    user[fieldName][attr] = value as (typeof targetField)[typeof attr];
  }
}

// 使用示例
setValue(408, PhoneNumber, 'phone', 'prefix');
setValue(555, PhoneNumber, 'phones', 0, 'exchange'); // 更新数组第一个元素的exchange属性

备选方案：拆分处理函数 #

如果业务场景中对象结构差异极大，重载函数会变得复杂，此时拆分函数是更清晰的选择：

• 单独写setObjectField处理单个对象属性
• 写setArrayField处理数组元素的属性更新
• 各自维护独立的泛型约束，代码可读性更高

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