Texte Dactylographié En Double Fonction De Mise En Œuvre

J'ai défini deux signatures de fonction dans le même texte dactylographié de la classe, c'est à dire,

public emit<T1>(event: string, arg1: T1): void {}

et

public emit<T1,T2>(event: string, arg1: T1, arg2: T2): void {}

Toutefois, lorsque transpiling le tapuscrit j'obtiens l'erreur suivante

error TS2393: Duplicate function implementation.

J'ai pensé que vous pourriez surcharge de fonctions en caractères d'imprimerie le nombre de paramètres de la fonction de signature ont été différents. Étant donné que les signatures ont 2 et 3 paramètres respectivement, pourquoi suis-je ce transpilation erreur?

Il n'y a pas de surcharge de fonctions en caractères d'imprimerie, pas même sans les génériques.
Veuillez lire la documentation sur la surcharge de plus près. La surcharge ne signifie pas que vous pouvez fournir plusieurs implémentations; cela signifie que vous vous pouvez fournir plusieurs signatures, avec une seule mise en œuvre. Mais dans ce cas pourquoi n'êtes-vous pas simplement d'écrire arg2??
Je suis en train d'assurer la sécurité de type à travers les génériques. Si j'utilise arg2? je vais encore avoir à fournir le type générique T2 dans emit<T1,T2> même si je risque de ne pas être à l'aide de T2. Je suppose que je suis en train de réaliser quelque chose de similaire à c#'s Func et Action délégué signatures. Mais il pourrait y avoir une meilleure façon.
Si vous faites référence à fournir le type générique T2 dans le définition de la fonction, cette nuit à rien. Si vous reportant à la section appel la fonction, de tout type, comme dans emit<number, string> ne devrait pas être nécessaire puisque types va être capté par les types des arguments. De toute façon, si nécessaire, écrire les deux déclarations sans corps (juste un point-virgule), puis d'écrire un la mise en œuvre que d'une certaine façon vérifie la présence de arg2, ou peut-être de lui assigner une valeur par défaut.

OriginalL'auteur James B | 2016-09-25

  1. 13

    Je suis en supposant que votre code ressemble à ceci:

    public emit<T1>(event: string, arg1: T1): void {}
public emit<T1,T2>(event: string, arg1: T1, arg2: T2): void {}
public emit(event: string, ...args: any[]): void {
    //actual implementation here
}

    Le problème, c'est que vous avez {} après les 2 premières lignes. Cela définit en fait un vide de la mise en œuvre d'une fonction, c'est à dire quelque chose comme:

    function empty() {}

    Vous ne souhaitez définir un type pour la fonction, pas un mise en œuvre. Afin de remplacer les blocs vides avec juste un point-virgule:

    public emit<T1>(event: string, arg1: T1): void;
public emit<T1,T2>(event: string, arg1: T1, arg2: T2): void;
public emit(event: string, ...args: any[]): void {
    //actual implementation here
}
    Lorsque vous surchargez à la Machine, vous n'avez qu'une mise en œuvre avec plusieurs signatures. Voir stackoverflow.com/questions/13212625/...
    De sorte que si trois de la fonction contient des logiques différentes?
    Il y a trois signatures, mais juste une mise en œuvre. Si vous avez besoin d'une logique différente selon que la signature a été utilisé, vous aurez besoin d'ajouter des contrôles supplémentaires à l'intérieur de votre mise en œuvre. Par exemple, vous pourriez vérifier args.length à la figure si seulement arg1 était passé, ou si les deux arg1 et arg2 ont été adoptées.

    OriginalL'auteur Mattias Buelens