将JS类转为TS时，如何解决动态键与方法的类型冲突？

方案1：使用泛型类精确推断属性类型 #

这种方案既能保留原有调用结构，又能让TS精确识别动态属性的类型，从根源上避免索引签名冲突：

class Row<T extends Record<string, number>> {
  constructor(data: T) {
    Object.assign(this, data);
  }

  addRow<K extends string>(data: Record<K, number>) {
    Object.assign(this, data);
    // 返回更新后的实例类型，自动包含新增属性
    return this as Row<T & Record<K, number>>;
  }
}

// 使用示例
const row = new Row({ eur: 10 });
console.log(row.eur); // TS自动推断为number类型
const updatedRow = row.addRow({ usd: 20 });
console.log(updatedRow.usd); // 同样自动推断为number

优点：类型安全，TS能自动追踪所有动态属性的类型；外部调用逻辑和原JS完全一致。
缺点：如果属性键名完全是运行时动态生成的，泛型的类型提示会受限，但不影响功能正常运行。

方案2：放宽索引签名兼容方法类型 #

如果不需要极致的类型精确性，只是想快速消除编译错误，可以让索引签名同时兼容动态属性和方法的类型：

class Row {
  // 允许string键对应number类型或addRow方法类型
  [key: string]: number | ((data: Record<string, number>) => void);

  constructor(data: Record<string, number>) {
    Object.assign(this, data);
  }

  addRow(data: Record<string, number>) {
    Object.assign(this, data);
  }
}

// 使用时需对动态属性做类型断言
const row = new Row({ eur: 10 });
const eur = row.eur as number;
row.addRow({ usd: 20 });
const usd = row.usd as number;

优点：实现简单，快速解决错误；外部调用结构不变。
缺点：访问动态属性时需要手动添加类型断言，存在一定的类型安全风险。

方案3：封装动态属性到独立字段（外部无感知） #

如果可以接受内部实现调整，但希望外部调用逻辑完全和原JS一致，可以把动态属性放到专门的字段中，通过get/set代理访问：

class Row {
  private data: Record<string, number> = {};

  constructor(data: Record<string, number>) {
    this.data = { ...data };
  }

  // 代理所有未知属性的读取
  get [key: string](): number | undefined {
    return this.data[key];
  }

  // 代理所有未知属性的赋值
  set [key: string](value: number) {
    this.data[key] = value;
  }

  addRow(data: Record<string, number>) {
    this.data = { ...this.data, ...data };
  }
}

// 外部调用和原JS完全一致
const row = new Row({ eur: 10 });
console.log(row.eur); // TS推断为number | undefined
row.addRow({ usd: 20 });
console.log(row.usd);

优点：类型安全，方法和动态属性完全分离，无冲突；外部调用逻辑无任何变化。
缺点：内部增加了data字段，和原JS的直接挂载实现有差异，但外部完全感知不到。

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