如何使对象工厂保持类型

Question

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

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");

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

ObjectFactory.getInstance<SomeInterface>("SomeInterface")

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

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

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

let DEFAULT_IMPLEMENTATIONS = {
    SomeInterface: Implementation
}

Answer 1

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

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

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;
    }
  }
}

我将您的版本重构为编译器大部分可以验证为类型安全的版本，以避免type assertions。让我们来看看吧。

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

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

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

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 对象调用makeFactory 来创建ObjectFactory。这里我注释了SomeInterface 属性返回一个SomeInterface 类型的值（否则编译器会推断Implementation 可能比你想要的更具体）。

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

---

Playground link to code