Mise à jour pour plus de clarté. Overload dactylographiée est une fonction utile dans la mesure où il vous permet de créer des définitions de type pour les bibliothèques existantes avec une API qui doit être représenté.

Lorsque vous rédigez votre propre code, bien que, vous pourriez bien être en mesure d'éviter la surcharge cognitive des paramètres optionnels à l'aide des surcharges ou par défaut. Telle est l'alternative plus lisible à la méthode et les surcharges maintient également votre API honnête que vous éviter de créer avec la commande unintuitive surcharges.

La loi générale de surchargent tapuscrit est:

Si vous pouvez supprimer les signatures de surcharge et tous vos tests passent, vous n'avez pas besoin dactylographiées surcharges

Vous pouvez obtenir généralement la même chose avec des paramètres facultatifs, ou par défaut - ou types d'union, ou avec un peu d'orientation de l'objet.

La question réelle

La question réelle demande une surcharge de:

someMethod(stringParameter: string): void {

someMethod(numberParameter: number, stringParameter: string): void {

Maintenant, même dans les langues qui prennent en charge avec des implémentations différentes surcharges (note: tapuscrit partagent une surcharge seule implémentation) - programmeurs sont des conseils pour assurer la cohérence dans la commande. Cela rendrait les signatures:

someMethod(stringParameter: string): void {

someMethod(stringParameter: string, numberParameter: number): void {

Le stringParameterest toujours nécessaire, il va d' abord. Vous pouvez écrire cela comme une surcharge de travail tapuscrit:

someMethod(stringParameter: string): void;
someMethod(stringParameter: string, numberParameter: number): void;
someMethod(stringParameter: string, numberParameter?: number): void {
    if (numberParameter != null) {
        // The number parameter is present...
    }
}

Mais après la loi de tapuscrit surcharges, nous pouvons supprimer les signatures de surcharge et tous nos tests vont passer encore.

someMethod(stringParameter: string, numberParameter?: number): void {
    if (numberParameter != null) {
        // The number parameter is present...
    }
}

La question réelle, dans l'ordre réel

Si vous déterminé à persister dans l'ordre d'origine, les surcharges seraient:

someMethod(stringParameter: string): void;
someMethod(numberParameter: number, stringParameter: string): void;
someMethod(a: string | number, b?: string | number): void {
  let stringParameter: string;
  let numberParameter: number;

  if (typeof a === 'string') {
    stringParameter = a;
  } else {
    numberParameter = a;

    if (typeof b === 'string') {
      stringParameter = b;
    }
  }
}

Maintenant, c'est beaucoup de ramification pour déterminer où placer les paramètres, mais vous vouliez vraiment préserver cet ordre si vous lisez loin ... mais attendez, ce qui se passe si l'on applique la loi de tapuscrit surcharges?

someMethod(a: string | number, b?: string | number): void {
  let stringParameter: string;
  let numberParameter: number;

  if (typeof a === 'string') {
    stringParameter = a;
  } else {
    numberParameter = a;

    if (typeof b === 'string') {
      stringParameter = b;
    }
  }
}

Assez Branching Déjà

Bien sûr, étant donné la quantité de type vérification que nous devons faire ... peut-être la meilleure réponse est simplement d'avoir deux méthode:

someMethod(stringParameter: string): void {
  this.someOtherMethod(0, stringParameter);
}

someOtherMethod(numberParameter: number, stringParameter: string): void {
  //...
}

Je souhaite que. Je veux que cette fonction aussi, mais a besoin tapuscrit être interopérable avec JavaScript typées qui n'a pas les méthodes surchargées. Autrement dit, si votre méthode surchargée est appelée à partir de JavaScript alors il ne peut s'envoi à une seule mise en œuvre de la méthode.

Il \ Sá quelques discussions pertinentes sur CodePlex. par exemple

https://typescript.codeplex.com/workitem/617

Je pense toujours tapuscrit devrait générer tous les if'ing et la commutation de sorte que nous ne serait pas nécessaire de le faire.

Javascript n'a pas notion de surcharge. Tapuscrit est pas c # ou Java.

Mais vous pouvez mettre en œuvre une surcharge dactylographiée.

Lire la suite http://www.gyanparkash.in/function-overloading-in-typescript/

Pourquoi ne pas utiliser l' interface définie de propriété facultative comme argument de fonction ..

Pour le cas dans cette question, à l'aide d'une interface en ligne définie avec des propriétés facultatives ne pouvait faire directement le code comme quelque chose ci-dessous:

class TestClass {

    someMethod(arg: { stringParameter: string, numberParameter?: number }): void {
        let numberParameterMsg = "Variant #1:";
        if (arg.numberParameter) {
            numberParameterMsg = `Variant #2: numberParameter = ${arg.numberParameter},`;
        }
        alert(`${numberParameterMsg} stringParameter = ${arg.stringParameter}`);
    }
}

var testClass = new TestClass();
testClass.someMethod({ stringParameter: "string for v#1" });
testClass.someMethod({ numberParameter: 12345, stringParameter: "string for v#2" });

Parce que la surcharge fourni dactylographiée est, comme mentionné dans les commentaires des autres, juste une liste des différentes signatures de fonction sans soutenir les codes de mise en œuvre correspondants comme d'autres langues statiques. Ainsi, la mise en œuvre doivent encore être fait dans un seul corps de la fonction, ce qui rend l'utilisation de la fonction surcharge dactylographiée pas aussi confortable que ces langages supportant la fonction réelle de surcharge.

Cependant, il y a encore beaucoup d'étoffes nouvelles et pratiques fournis dactylographiée qui n'est pas disponible dans le langage de programmation existant, où le soutien de la propriété en option dans une interface anonyme est une telle approche pour répondre à la zone de confort de la surcharge de fonction héritage, je pense.

class User{
   name : string;
   age : number;
   constructor(name:string,age:number){
    this.name = name;
    this.age = age;
    console.log("User " +this.name+ " Created")
}
getName(name:string = ""):string{
    if(name != ""){
        return name + " " +this.name;
    }else{
        return this.name;
    }
  }

}

Je pense que cela devrait fonctionner