Update für Klarheit. Verfahren in Typoskript Überlastung ist eine nützliche Funktion, soweit es Ihnen erlaubt, Typdefinitionen für bestehende Bibliotheken mit einer API zu erstellen, die dargestellt werden muss.

Wenn Sie Ihren eigenen Code zu schreiben, obwohl, können Sie auch in der Lage sein, den kognitiven Aufwand von Überlastungen Parametern optional oder Standard zu vermeiden. Dies ist die lesbare Alternative zur Methode Überlastungen und hält auch Ihre API ehrlich, wie Sie Überlastungen mit unintuitive Ordnung zu schaffen vermeiden werden.

Das allgemeine Gesetz der Typoskript Überlastungen ist:

Wenn Sie die Überlastung Signaturen löschen und alle Ihre Tests bestehen, müssen Sie nicht Typoskript Überlastungen

Sie können in der Regel die gleiche Sache mit optional oder Standardparameter erreichen - oder mit Union-Typen, oder mit einem bisschen Objektorientierung.

Die eigentliche Frage

Die eigentliche Frage bittet um eine Überlastung von:

someMethod(stringParameter: string): void {

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

Jetzt auch in Sprachen, die Überlastungen mit getrennten Implementierungen (Anmerkung: Typoskript Überlastungen teilen sich eine einzige Implementierung) unterstützen - Programmierer sind Ratschläge Konsistenz bei der Bestellung zu liefern. Dies würde die Unterschriften machen:

someMethod(stringParameter: string): void {

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

Das stringParameterist immer dann erforderlich, so dass es zuerst geht. Man könnte dies als Arbeits Typoskript Überlastung schreiben:

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

Aber nach dem Gesetz von Typoskript Überlastungen können wir die Überlastung Signaturen löschen und alle unsere Tests noch passieren.

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

Die eigentliche Frage, in der eigentlichen Bestellung

Wenn Sie mit der ursprünglichen Reihenfolge bestehen bleiben bestimmt wurden, wären die Überlastungen:

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;
    }
  }
}

Nun, das ist eine Menge Verzweigung zu arbeiten, wo die Parameter zu setzen, aber man wollte wirklich diese Bestellung erhalten, wenn Sie bis hierher lesen ... aber warten, was passiert, wenn wir das Gesetz der Typoskript Überlastungen gelten?

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;
    }
  }
}

Genug Branching Bereits

Natürlich, da wir die Menge der Typprüfung tun müssen, ... vielleicht ist die beste Antwort einfach zwei Verfahren zu haben:

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

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

Ich wünsche. Ich mag diese Funktion auch, aber Typoskript muss mit untypisierten JavaScript kompatibel sein, den überladenen Methoden nicht hat. dh Wenn Ihre überladene Methode von JavaScript aufgerufen wird, dann kann es nur eine Methode Implementierung geschickt bekommen.

Es \ sa einige relevante Diskussionen auf Codeplex. z.B

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

Ich denke immer noch Typoskript sollten alle if'ing erzeugen und Schalen so haben wir es nicht tun müssen.

Javascript hat keinen Begriff von Überlastung. Typoskript ist nicht c # oder Java.

Aber man kann eine Überlastung in Typoskript implementieren.

Lesen Sie diesen Beitrag http://www.gyanparkash.in/function-overloading-in-typescript/

Warum nicht verwenden optionale Eigenschaft definierte Schnittstelle als Funktionsargument ..

Für den Fall, in dieser Frage eine Inline-Schnittstelle definiert mit einigen optionalen Eigenschaften mit nur direkt Code wie etwas weiter unten machen könnte:

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" });

Da in Typoskript vorgesehen Überlastung ist, wie es in den Kommentaren anderen Personen erwähnt, nur eine Liste von unterschiedlichen Signaturen der Funktion ohne entsprechende Implementierung Codes wie andere statische Sprachen zu unterstützen. So hat die Umsetzung noch in nur eine Funktion Körper getan werden, was die Verwendung der Funktion in Typoskript Überlastung macht nicht so komfortabel wie solche Sprachen die reale Überlastung Funktion unterstützen.

Es gibt jedoch noch viele neue und bequeme Stoffe vorgesehen in Typoskript ist, die in Legacy-Programmiersprache nicht verfügbar ist, wo optionale Eigenschaft Unterstützung in einer anonymen Schnittstelle ein solcher Ansatz ist die komfortable Zone aus der Legacy-Funktion Überlastung gerecht zu werden, denke ich.

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;
    }
  }

}

Ich denke, das sollte funktionieren