Typescript如何实现工厂模式

Question

I'm newbie to typescript, and trying to implement kind of factory pattern. Here is the example. I have two methods "getCat" and "getDog", and each of them takes different arguments. And an object "pet" which maps key and corresponding method. I am trying to create a factory "getPet", pass in "type" and corresponding arguments.

But I am not sure how can the "arg" been typed (now it is any), and how to restrict if type is 'cat', the argument is for 'cat' (that has meow method)?

interface CatArg {name: string; meow: () => string; }
interface DogArg {name: string; bark: () => string; }


function getCat({name: string, meow}: CatArg) {
    meow();
}

function getDog({name: string, bark}: DogArg) {
    bark();
}

const pet = {
    cat: getCat,
    dog: getDog
};

function playWithPet(type: 'cat' | 'dog', arg: any) {
    switch (type) {
        case 'cat':
            return pet.cat(arg);
        case 'dog':
            return pet.dog(arg);
    }
}

playWithPet('cat', {name: 'Kitty', meow: () => 'dont touch me'});
playWithPet('dog', {name: 'Bella', bark: () => 'play with me'});

Answer 1

You can use function overloading like so

function playWithPet( type: 'cat', arg: CatArg): void
function playWithPet( type: 'dog', arg: DogArg ): void
function playWithPet( type, arg ) {
    switch (type) {
        case 'cat':
            return pet.cat(arg);
        case 'dog':
            return pet.dog(arg);
    }
}

Note: I'm returning void because your getCat and getDog aren't returning anything. So this function should make it clear nothing is returned, overall I would refactor the code.

Now it will check that the correct object is passed for the second parameter

Another way to do it is this way

interface PlayWithPet {
  ( type: 'cat', arg: CatArg ): void
  ( type: 'dog', arg: DogArg ): void
}

const playWithPet: PlayWithPet = ( type, arg ) => {
    switch (type) {
        case 'cat':
            return pet.cat(arg);
        case 'dog':
            return pet.dog(arg);
    }
}

Answer 2

In general TypeScript does not encourage such usage but with 3.2+ you can make it work by using tuple types for rest arguments together with discriminated unions:

function playWithPet(...args: ['cat', CatArg] | ['dog', DogArg]): void {
  switch (args[0]) {
  case 'cat':
    return pet.cat(args[1]);
  case 'dog':
    return pet.dog(args[1]);
  }
}