如何制作 Object 工厂维护类型

Question

我创建了以下 object 工厂来实例化我所有接口的实现：

interface SomeInterface {
  get(): string;
}

class Implementation implements SomeInterface {
  constructor() {}
  get() {
    return "Hey :D";
  }
}

type Injectable = {
  [key: string]: () => unknown;
};

// deno-lint-ignore prefer-const
let DEFAULT_IMPLEMENTATIONS: Injectable = {
  SomeInterface: () => new Implementation(),
};

let MOCK_IMPLEMENTATIONS: Injectable = {};

class Factory {
  static getInstance(interfaceName: string, parameters: unknown = []) {
    if (MOCK_IMPLEMENTATIONS[interfaceName])
      return MOCK_IMPLEMENTATIONS[interfaceName]();
    return DEFAULT_IMPLEMENTATIONS[interfaceName]();
  }

  static mockWithInstance(interfaceName: string, mock: unknown) {
    MOCK_IMPLEMENTATIONS[interfaceName] = () => mock;
  }
}

export const ObjectFactory = {
  getInstance<T>(name: string): T {
    return Factory.getInstance(name) as T;
  },

  mockWithInstance: Factory.mockWithInstance,
};

const impl = ObjectFactory.getInstance<SomeInterface>("SomeInterface");

如您所见，这个工厂允许您实例化这些接口和 mocking。 主要问题是我必须使用接口名称和接口名称调用此 function 以保持分配中的类型：

ObjectFactory.getInstance<SomeInterface>("SomeInterface")

我见过这个问题，但我不喜欢使用Base接口的想法。 此外，这种方法也不会保留类型。

理想情况下，我想使用我的方法，但不必使用接口，即只使用接口的名称。

旁注： Injectable的声明是使该代码工作的一种技巧，理想情况下，我希望能够仅使用实现名称，即：

let DEFAULT_IMPLEMENTATIONS = {
    SomeInterface: Implementation
}

Answer 1

由于您有一个您关心支持的名称到类型映射的固定列表，因此这里的一般方法是根据代表此映射的 object 类型T来考虑，然后对于任何受支持的接口名称K extends keyof T ，您将正在处理以该名称返回属性的函数......即() => T[K]类型的函数。 另一种说法是，我们将使用keyof和查找类型来帮助为您的工厂提供类型。

我们只会使用像{"SomeInterface": SomeInterface; "Date": Date}这样的具体类型。 {"SomeInterface": SomeInterface; "Date": Date}用于T ，但是如果T是通用的，那么编译器会更容易处理。 这是ObjectFactory制造商的一个可能的通用实现：

function makeFactory<T>(DEFAULT_IMPLEMENTATIONS: { [K in keyof T]: () => T[K] }) {
  const MOCK_IMPLEMENTATIONS: { [K in keyof T]?: () => T[K] } = {};
  return {
    getInstance<K extends keyof T>(interfaceName: K) {
      const compositeInjectable: typeof DEFAULT_IMPLEMENTATIONS = {
        ...DEFAULT_IMPLEMENTATIONS,
        ...MOCK_IMPLEMENTATIONS
      };
      return compositeInjectable[interfaceName]();
    },
    mockWithInstance<K extends keyof T>(interfaceName: K, mock: T[K]) {
      MOCK_IMPLEMENTATIONS[interfaceName] = () => mock;
    }
  }
}

我将您的版本重构为编译器主要可以验证为类型安全的版本，以避免类型断言。 让我们来看看它。

makeFactory function 在 object 映射类型T中是通用的，并采用类型为{ [K in keyof T]: () => T[K] }的名为DEFAULT_IMPLEMENTATIONS的参数。 这是一个映射类型，其键K与T的键相同，但其属性是返回T[K]类型值的零参数函数。 您可以看到现有的DEFAULT_IMPLEMENTATIONS是这样的：每个属性都是零参数 function 返回相应接口的值。

在 function 实现中，我们创建MOCK_IMPLEMENTATIONS 。 此变量具有与DEFAULT_IMPLEMENTATIONS几乎相同的类型，但属性是可选的（受[K in keyof T]?中的可选修饰符?影响）。

function返回工厂本身，有两种方法：

getInstance方法在接口名称的类型K中是泛型的，返回值是对应接口属性的类型T[K] 。 我通过object spread合并DEFAULT_IMPLEMENTATIONS和MOCK_IMPLEMENTATIONS来实现这一点，并注释这个compositeInjectable与DEFAULT_IMPLEMENTATIONS类型相同。 然后我们使用interfaceName对其进行索引并调用它。

mockWithInstance方法在接口名称的类型K中也是泛型的，并且接受类型为K的参数（接口名称）和类型为T[K]的参数（对应的接口）。

---

让我们看看它的实际效果：

const ObjectFactory = makeFactory({
  SomeInterface: (): SomeInterface => new Implementation(),
  Date: () => new Date()
});

console.log(ObjectFactory.getInstance("SomeInterface").get().toUpperCase()); // HEY :D
ObjectFactory.mockWithInstance("SomeInterface", { get: () => "howdy" });
console.log(ObjectFactory.getInstance("SomeInterface").get().toUpperCase()); // HOWDY
console.log(ObjectFactory.getInstance("Date").getFullYear()); // 2020

这一切都如我所料。 我们通过使用所需的DEFAULT_IMPLEMENTATIONS object 调用makeFactory来创建ObjectFactory 。 在这里，我注释了SomeInterface属性返回SomeInterface类型的值（否则编译器会推断出可能比您想要的更具体的Implementation ）。

然后我们可以看到编译器允许我们使用正确的 arguments 调用ObjectFactory.getInstance()和ObjectFactory.mockWithInstance()并返回预期的类型，并且它也可以在运行时工作。

---

Playground 代码链接