Abschnitt 6.3 der TypeScript-Sprachspezifikation befasst sich mit der Überladung von Funktionen und gibt konkrete Beispiele für deren Implementierung. Wenn ich jedoch so etwas versuche:

export class LayerFactory { 

    constructor (public styleFactory: Symbology.StyleFactory) { }

    createFeatureLayer (userContext : Model.UserContext, mapWrapperObj : MapWrapperBase) : any {           
         throw "not implemented";
    }                 

    createFeatureLayer(layerName : string, style : any) : any {
        throw "not implemented";
     }        

}

Ich erhalte einen Compilerfehler, der auf eine doppelte Kennung hinweist, obwohl die Funktionsparameter unterschiedlich sind. Selbst wenn ich der zweiten Funktion createFeatureLayer einen zusätzlichen Parameter hinzufüge, wird immer noch ein Compilerfehler angezeigt. Ideen bitte.

Dies kann daran liegen, dass beim Kompilieren beider Funktionen zu JavaScript die Signatur völlig identisch ist. Da JavaScript keine Typen hat, erstellen wir am Ende zwei Funktionen mit der gleichen Anzahl von Argumenten. TypeScript hindert uns also daran, solche Funktionen zu erstellen.

TypeScript unterstützt das Überladen basierend auf der Anzahl der Parameter, aber die zu befolgenden Schritte unterscheiden sich etwas, wenn wir sie mit OO-Sprachen vergleichen. Als Antwort auf eine andere SO-Frage erklärte es jemand mit einem schönen Beispiel: Methodenüberladung? .

Grundsätzlich erstellen wir nur eine Funktion und eine Reihe von Deklarationen, damit TypeScript keine Kompilierungsfehler verursacht. Wenn dieser Code in JavaScript kompiliert wird, ist nur die konkrete Funktion sichtbar. Da eine JavaScript-Funktion durch Übergabe mehrerer Argumente aufgerufen werden kann, funktioniert sie einfach.

Wenn Sie in TypeScript überladen, haben Sie nur eine Implementierung mit mehreren Signaturen.

class Foo {
    myMethod(a: string);
    myMethod(a: number);
    myMethod(a: number, b: string);
    myMethod(a: any, b?: string) {
        alert(a.toString());
    }
}

Nur die drei Überladungen werden von TypeScript als mögliche Signaturen für einen Methodenaufruf erkannt, nicht die eigentliche Implementierung.

In Ihrem Fall würde ich persönlich zwei Methoden mit unterschiedlichen Namen verwenden, da die Parameter nicht genügend Gemeinsamkeiten aufweisen. Daher ist es wahrscheinlich, dass der Methodenkörper viele "Wenns" benötigt, um zu entscheiden, was zu tun ist.

TypeScript 1.4

Ab TypeScript 1.4 können Sie normalerweise die Notwendigkeit einer Überladung mithilfe eines Union-Typs beseitigen. Das obige Beispiel kann besser ausgedrückt werden mit:

myMethod(a: string | number, b?: string) {
    alert(a.toString());
}

Der Typ von aist "entweder stringoder number".

Sie können erklären , eine überladene Funktion , indem er erklärt die Funktion als mit einem Typ, der mehr Aufruf Unterschriften hat:

interface IFoo
{
    bar: {
        (s: string): number;
        (n: number): string;
    }
}

Dann folgendes:

var foo1: IFoo = ...;

var n: number = foo1.bar('baz');     // OK
var s: string = foo1.bar(123);       // OK
var a: number[] = foo1.bar([1,2,3]); // ERROR

Die tatsächliche Definition der Funktion muss singulär sein und den entsprechenden internen Versand für ihre Argumente durchführen.

Beispiel: Verwenden einer Klasse (die implementiert werden könnte IFoo, aber nicht muss):

class Foo
{
    public bar(s: string): number;
    public bar(n: number): string;
    public bar(arg: any): any 
    {
        if (typeof(arg) === 'number')
            return arg.toString();
        if (typeof(arg) === 'string')
            return arg.length;
    }
}

Interessant ist hier, dass das anyFormular durch die spezifisch typisierten Überschreibungen ausgeblendet wird.

var foo2: new Foo();

var n: number = foo2.bar('baz');     // OK
var s: string = foo2.bar(123);       // OK
var a: number[] = foo2.bar([1,2,3]); // ERROR

Was ist Funktionsüberladung im Allgemeinen?

Überladen von Funktionen oder Verfahren Überlastung ist die Fähigkeit, erstellen mehrere Funktionen des gleichen Namens mit unterschiedlichen Implementierungen ( Wikipedia )

Was ist Funktionsüberladung in JS?

Diese Funktion ist in JS nicht möglich - die zuletzt definierte Funktion wird bei mehreren Deklarationen verwendet:

function foo(a1, a2) { return `${a1}, ${a2}` }
function foo(a1) { return `${a1}` } // replaces above `foo` declaration
foo(42, "foo") // "42"

... und in TS?

Überladungen sind ein Konstrukt zur Kompilierungszeit ohne Auswirkungen auf die JS-Laufzeit:

function foo(s: string): string // overload #1 of foo
function foo(s: string, n: number): number // overload #2 of foo
function foo(s: string, n?: number): string | number {/* ... */} // foo implementation

Ein doppelter Implementierungsfehler wird ausgelöst, wenn Sie den obigen Code verwenden (sicherer als JS). TS wählt die erste passende Überlast in Top-Down-Reihenfolge aus, sodass die Überlastungen von den spezifischsten bis zu den breitesten sortiert werden.

Methodenüberladung in TS: ein komplexeres Beispiel

Überladene Klassenmethodentypen können auf ähnliche Weise wie das Überladen von Funktionen verwendet werden:

class LayerFactory {
    createFeatureLayer(a1: string, a2: number): string
    createFeatureLayer(a1: number, a2: boolean, a3: string): number
    createFeatureLayer(a1: string | number, a2: number | boolean, a3?: string)
        : number | string { /*... your implementation*/ }
}

const fact = new LayerFactory()
fact.createFeatureLayer("foo", 42) // string
fact.createFeatureLayer(3, true, "bar") // number

Die sehr unterschiedlichen Überladungen sind möglich, da die Funktionsimplementierung mit allen vom Compiler erzwungenen Überlastsignaturen kompatibel ist.

Weitere Infos:

• Spielplatz Probe
• Do's and Don'ts für Überlastungen

Als Hinweis auf andere habe ich festgestellt, dass Sie, zumindest wie durch TypeScript, das von WebPack für Angular 2 kompiliert wurde, manifestiert werden, stillschweigend überschrieben werden, anstatt überladene Methoden.

myComponent {
  method(): { console.info("no args"); },
  method(arg): { console.info("with arg"); }
}

Berufung:

myComponent.method()

scheint die Methode mit Argumenten auszuführen, wobei die No-Arg-Version stillschweigend ignoriert wird, mit Ausgabe:

with arg

Funktionsüberladung im Typoskript:

Laut Wikipedia (und vielen Programmierbüchern) lautet die Definition der Überladung von Methoden / Funktionen wie folgt:

In einigen Programmiersprachen ist Funktionsüberladung oder Methodenüberladung die Möglichkeit, mehrere gleichnamige Funktionen mit unterschiedlichen Implementierungen zu erstellen . Aufrufe einer überladenen Funktion führen eine bestimmte Implementierung dieser Funktion aus, die dem Kontext des Aufrufs entspricht, sodass ein Funktionsaufruf je nach Kontext unterschiedliche Aufgaben ausführen kann.

In Typoskript können wir keine unterschiedlichen Implementierungen derselben Funktion haben, die entsprechend der Anzahl und Art der Argumente aufgerufen werden. Dies liegt daran, dass beim Kompilieren von TS zu JS die Funktionen in JS die folgenden Eigenschaften aufweisen:

• JavaScript-Funktionsdefinitionen geben keine Datentypen für ihre Parameter an
• JavaScript-Funktionen überprüfen beim Aufruf nicht die Anzahl der Argumente

Im engeren Sinne könnte man daher argumentieren, dass es keine Überladung der TS-Funktion gibt. Es gibt jedoch Dinge, die Sie in Ihrem TS-Code tun können, um die Funktionsüberladung perfekt nachzuahmen.

Hier ist ein Beispiel:

function add(a: number, b: number, c: number): number;
function add(a: number, b: number): any;
function add(a: string, b: string): any;

function add(a: any, b: any, c?: any): any {
  if (c) {
    return a + c;
  }
  if (typeof a === 'string') {
    return `a is ${a}, b is ${b}`;
  } else {
    return a + b;
  }
}

In den TS-Dokumenten wird diese Methodenüberladung aufgerufen. Grundsätzlich haben wir dem TS-Compiler mehrere Methodensignaturen (Beschreibungen möglicher Parameter und Typen) bereitgestellt. Jetzt kann TS herausfinden, ob wir unsere Funktion während der Kompilierungszeit korrekt aufgerufen haben, und uns einen Fehler geben, wenn wir die Funktion falsch aufgerufen haben.