Typescript : message de mise en œuvre d'une fonction en double

Question

J'ai créé ces deux méthodes d'usine statiques dans ma classe :

export class ConstantImpl<T> {
    public static create(b: Boolean): Constant<Boolean> {
        return new ConstantImpl<Boolean>(b);
    }

    public static create(i: Number): Constant<Number> {
        return new ConstantImpl<Number>(i);
    }
}

Cependant, je reçois ce message d'erreur de compilation :

Mise en œuvre de la fonction en double.

Des idées ?

Answer 1

Comme @cartant l'a suggéré, vous pouvez utiliser surcharges en TypeScript. Ils ont une seule implémentation mais plusieurs signatures. Vous pouvez lire le manuel à ce sujet pour voir comment faire en sorte que les signatures et l'implémentation fonctionnent bien ensemble. Dans votre cas, vous pouvez faire quelque chose comme ceci :

export class ConstantImpl<T> {
  // guessing at your constructor
  public constructor(public val: T) {

  }

  public static create(b: boolean): Constant<boolean>;
  public static create(i: number): Constant<number>;
  public static create(v: boolean | number): Constant<boolean | number> {
        return new ConstantImpl(v);
    }
}

Cela permettra seulement ConstantImpl.create() d'accepter un boolean ou un number et il rejettera tout le reste. Notez que je n'ai pas eu besoin d'inspecter le type de v pour voir si c'est un boolean ou un number et je n'ai pas eu à spécifier manuellement la valeur de l'option T dans l'appel à la ConstantImpl<T> car le constructeur déduit la valeur de T à partir de l'argument que vous passez.

Et vraiment, dans ce cas, je me demande pourquoi vous vous souciez de restreindre ConstantImpl.create() d'accepter uniquement boolean y number valeurs. Pourquoi ne pas opter plutôt pour la voie générique complète ?

  // accept any type
  public static create<T>(v: T): Constant<T> {
    return new ConstantImpl(v);
  }

J'espère que cela vous aidera ; bonne chance.

Answer 2

Comme je l'ai dit dans mon commentaire, la surcharge n'est pas implémentée dans Typescript comme elle l'est dans JAVA, par exemple.

Vous pouvez essayer quelque chose comme ça

export class ConstantImpl<T> {
    public static create(a: any): Constant<any> {
        if(typeof a == "Boolean")
           return ConstantImpl.createBoolean(a);
        if(typeof a == "Number")
           return ConstantImpl.createNumber(a);
    }
   public static createBoolean(b: Boolean): Constant<Boolean> {
    return new ConstantImpl<Boolean>(b);
   }

}

ps : Je n'ai pas testé/compilé cette fonction spécifique, c'est juste un exemple de type qui peut être présent.