如何在TypeScript类中使用映射类型并添加其他成员？

方法一：通过接口约束类成员 #

先把映射类型定义成接口，让类实现这个接口，既能保证类包含所有指定键，又能自由添加构造函数、方法等内容：

type Keys = 'foo' | 'bar' | 'baz';

// 定义包含所有必需键的接口
interface RequiredKeys {
  [K in Keys]: string;
}

class WithKeys implements RequiredKeys {
  foo: string;
  bar: string;
  baz: string;

  constructor(foo: string, bar: string, baz: string) {
    this.foo = foo;
    this.bar = bar;
    this.baz = baz;
  }

  // 可添加任意自定义方法
  logKeys() {
    console.log(this.foo, this.bar, this.baz);
  }
}

这种方式直观清晰，TypeScript会严格检查类是否实现了接口的所有成员，避免遗漏必需键。

方法二：构造函数中动态初始化所有键 #

如果键的数量较多，不想逐个声明属性，可以在构造函数里通过Object.assign动态赋值，同时用类型断言辅助TypeScript做类型推导：

type Keys = 'foo' | 'bar' | 'baz';
type RequiredKeys = { [K in Keys]: string };

class WithKeys {
  constructor(initialValues: RequiredKeys) {
    Object.assign(this, initialValues);
  }

  // 同样支持添加自定义方法
  getKeyValues() {
    return {
      foo: this.foo,
      bar: this.bar,
      baz: this.baz
    };
  }
}

// 类型断言让TypeScript认可实例符合RequiredKeys类型
const instance = new WithKeys({ foo: 'a', bar: 'b', baz: 'c' }) as WithKeys & RequiredKeys;

这种方式适合键数量多的场景，减少重复代码，同时保证类型合规。

方法三：抽象类+类型约束（适合继承场景） #

如果需要在基类中约束必需键，子类负责具体实现，可以用抽象类配合类型：

type Keys = 'foo' | 'bar' | 'baz';
type RequiredKeys = { [K in Keys]: string };

abstract class BaseWithKeys implements RequiredKeys {
  abstract foo: string;
  abstract bar: string;
  abstract baz: string;

  // 基类可定义通用逻辑方法
  commonLogic() {
    console.log('所有子类共享的逻辑');
  }
}

class WithKeys extends BaseWithKeys {
  foo: string;
  bar: string;
  baz: string;

  constructor(foo: string, bar: string, baz: string) {
    super();
    this.foo = foo;
    this.bar = bar;
    this.baz = baz;
  }
}

这种方式适合有继承需求的场景，把通用逻辑抽离到抽象基类中。

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