TypeScript：如何初始化依赖于T的泛型类的成员？

我有一个接口，它将

MyType

定义为包含一些函数：

interface MyType {
  function1(): void,
  function2(): void,
}

还有一个类，其成员类型为

MyMap

，如下所示：

type MyMap<T> = {[K in keyof T]: T[K][]};

class Example<T> {
  protected _map: MyMap<T>;
}

const var: MyMap<MyType> = {
  "function1" = Function[],
  "function2" = Function[],

    constructor(map: MyMap<T>) {
        this._map = map;
    }

我可以这样把地图递过来：

type MyMap<T> = {[K in keyof T]: T[K][]};

class Example<T> {
  protected _map: MyMap<T>;
}

const var: MyMap<MyType> = {
  "function1" = Function[],
  "function2" = Function[],

    constructor(map: MyMap<T>) {
        this._map = map;
    }

构造函数（映射：MyMap）{
这个._map=map；
}

但这种方法感觉不那么优雅

有没有更简洁的方法来实现我想要的

复制和粘贴的完整代码：

type FunctionRecord<T> = {[K in keyof T]: T[keyof T]};
type MyMap<T extends FunctionRecord<T>> = {[K in keyof T]: T[K][]};

class Example<T extends FunctionRecord<T>> {
  protected _map: MyMap<T>;

  constructor(map: MyMap<T>) {
    this._map = map;
  }

  push_to_map<K extends keyof T>(function_name: K, func: T[K]) {
    this._map[function_name].push(func);
  }

  do_for<K extends keyof T>(function_name: K) {
    this._map[function_name].forEach((func) => func());
  }
}

// example implementation:

interface MyHappyType {
  congratulate(): void,
  clap_hands(): void,
}

const happy_map = new Example<MyHappyType>({"congratulate": [], "clap_hands": []});
happy_map.push_to_map("congratulate", () => console.log("Yay"));
happy_map.do_for("congratulate");

type FunctionRecord={[K in keyof T]：T[keyof T]}；
类型MyMap={[K in keyof T]：T[K][]}；
课例{
受保护的地图：MyMap；
构造函数（映射：MyMap）{
这个._map=map；
}
推送到映射（函数名称：K，函数：T[K]）{
此.u映射[函数名称].push（func）；
}
do_for（函数名称：K）{
此.u映射[函数名称].forEach（（func）=>func（）；
}
}
//实施示例：
接口MyHappyType{
祝贺（）：无效，
鼓掌：无效，
}
const happy_map=新示例（{“祝贺”：[]，“拍手”：[]）；
快乐地图。将地图推到地图上（“祝贺”，（）=>console.log（“耶”）；
快乐地图。祝贺你；
问题是，分配给
MyMap
的“最空”的东西是
{祝贺：[]，拍手：[]}
。这些键是必需的，因此JS代码需要知道键的名称，不能简单地用空对象实例化

您可以允许
\u map
是不完整的
部分
，但是当
\u map
的属性不能保证定义时，您需要进行一些调整


class Example<T extends FunctionRecord<T>> {
    protected _map: Partial<MyMap<T>> = {};

    // helper method ensures that an array always exists
    protected _getArray<K extends keyof T>(function_name: K): T[K][] {
        // initialize if no array yet
        if (!this._map[function_name]) {
            this._map[function_name] = [];
        }
        // circumventing TS error that it could be undefined
        return this._map[function_name] as T[K][];
    }

    push_to_map<K extends keyof T>(function_name: K, func: T[K]) {
        this._getArray(function_name).push(func);
    }

    do_for<K extends keyof T>(function_name: K) {
        this._getArray(function_name).forEach((func) => func());
    }
}


课例{
受保护的_映射：部分={}；
//helper方法确保数组始终存在
受保护的数组（函数名称：K）：T[K][]{
//如果还没有数组，则初始化
如果（！this.\u映射[函数名称]）{
此._映射[函数名称]=[]；
}
//避免TS错误，它可能是未定义的
将此返回。_映射[函数名称]作为T[K][]；
}
推送到映射（函数名称：K，函数：T[K]）{
这是.getArray（函数名）.push（func）；
}
do_for（函数名称：K）{
这个.u getArray（函数名称）.forEach（（func）=>func（））；
}
}