打字稿-工厂模式

Question

I'm trying to create factory for MainType . I would also like to reuse already created types (actually I need same instance) so I store them within ItemFactory .

class BaseType {

}

class MainType extends BaseType {

}

class ItemFactory {
    items: { [type: string]: BaseType } = {};

    get<T extends BaseType>(type: string): T | null {
        let item = this.items[type];

        if (!item) {
            switch (type) {
                case "main-type":
                    item = new MainType();
                    break;
                default:
                    return null;
            }

            this.items[type] = item;
        }

        return item as T;
    }
}

Is there a way to simplify call

itemFactory.get<MainType>("main-type"); // current call

// option 1
const resolvedType = itemFactory.get<MainType>();

// option 2
const resolvedType = itemFactory.get("main-type");

I would like to have either option 1 or option 2 (no need for both), so I don't have to pass both identifier and type to have correctly resolved resulting type.

Answer 1

You'll need to give the compiler some kind of mapping between names passed to itemFactory.get() and the expected output type. Mapping from names to types is what interface s do best, so you can define one like this:

interface NameMap {
  "main-type": MainType;
  // other name-type mappings here
}

And then you change your get() method to this:

  get<K extends keyof NameMap>(type: K): NameMap[K] | null {
    let item = this.items[type];

    if (!item) {
      switch (type) {
        case "main-type":
          item = new MainType();
          break;
        default:
          return null;
      }

      this.items[type] = item;
    }

    return item as NameMap[K];
  }

You replace T extends BaseType to NameMap[K] where K extends keyof NameMap . Now the following ("option 2") will work:

const resolvedType = itemFactory.get("main-type"); // MainType | null

---

Note that you will never get "option 1" to work. TypeScript's type system gets erased when the JS is emitted, so this:

itemFactory.get<MainType>();

will become this at runtime:

itemFactory.get();

And there's no way for that to know what to return, since the relevant information has been left behind before the code started running. This is intentional; it is not a goal of TypeScript to "add or rely on run-time type information in programs, or emit different code based on the results of the type system." Instead, TypeScript should "encourage programming patterns that do not require run-time metadata"... in this case it means using a runtime value like the string "main-type" instead of a design-time type like MainType to keep track of what get() should do.

---

Okay, hope that helps. Good luck!

Link to code