Gibt es eine Möglichkeit, Methoden in TypeScript zu überladen?

Question

Gibt es eine Möglichkeit, Methoden in TypeScript-Sprache zu überladen?

Ich möchte so etwas erreichen:

class TestClass {
    someMethod(stringParameter: string): void {
        alert("Variant #1: stringParameter = " + stringParameter);
    }

    someMethod(numberParameter: number, stringParameter: string): void {
        alert("Variant #2: numberParameter = " + numberParameter + ", stringParameter = " + stringParameter);
    }
}

var testClass = new TestClass();
testClass.someMethod("string for v#1");
testClass.someMethod(12345, "string for v#2");

Hier ist ein Beispiel dafür, was ich nicht tun möchte (ich hasse diesen Teil des Überladens von Hack in JS wirklich):

class TestClass {
    private someMethod_Overload_string(stringParameter: string): void {
        // A lot of code could be here... I don't want to mix it with switch or if statement in general function
        alert("Variant #1: stringParameter = " + stringParameter);
    }

    private someMethod_Overload_number_string(numberParameter: number, stringParameter: string): void {
        alert("Variant #2: numberParameter = " + numberParameter + ", stringParameter = " + stringParameter);
    }

    private someMethod_Overload_string_number(stringParameter: string, numberParameter: number): void {
        alert("Variant #3: stringParameter = " + stringParameter + ", numberParameter = " + numberParameter);
    }

    public someMethod(stringParameter: string): void;
    public someMethod(numberParameter: number, stringParameter: string): void;
    public someMethod(stringParameter: string, numberParameter: number): void;

    public someMethod(): void {
        switch (arguments.length) {
        case 1:
            if(typeof arguments[0] == "string") {
                this.someMethod_Overload_string(arguments[0]);
                return;
            }
            return; // Unreachable area for this case, unnecessary return statement
        case 2:
            if ((typeof arguments[0] == "number") &&
                (typeof arguments[1] == "string")) {
                this.someMethod_Overload_number_string(arguments[0], arguments[1]);
            }
            else if ((typeof arguments[0] == "string") &&
                     (typeof arguments[1] == "number")) {
                this.someMethod_Overload_string_number(arguments[0], arguments[1]);
            }
            return; // Unreachable area for this case, unnecessary return statement
        }
    }
}


var testClass = new TestClass();
testClass.someMethod("string for v#1");
testClass.someMethod(12345, "string for v#2");
testClass.someMethod("string for v#3", 54321);

Answer 1

Gemäß der Spezifikation unterstützt das Typenkript, dass das Musterverfahren überlastet ist, aber es ist ziemlich unbeholfen und umfasst viele manuelle Arbeitstypen von Parametern.Ich denke, es ist meistens daran, dass der nächste, den Sie in der Nähe von JavaScript erreichen können, um diese Überprüfung zu überladen.

Wenn ich es richtig verstehe, müssen Sie zuerst eine Methodendeklaration für jede der Überlastungen und dann One -Methodenimplementierung schreiben, die seine Argumente überprüft, um zu entscheiden, welche Überlast aufgerufen wurde.Die Unterschrift der Implementierung muss mit allen Überlastungen kompatibel sein. generasacodicetagpre.

Answer 2

Update für Klarheit.Das Überladen von Methoden in TypeScript ist insofern eine nützliche Funktion, als Sie damit Typdefinitionen für vorhandene Bibliotheken mit einer API erstellen können, die dargestellt werden muss.

Wenn Sie jedoch Ihren eigenen Code schreiben, können Sie möglicherweise den kognitiven Overhead von Überladungen mithilfe optionaler oder Standardparameter vermeiden.Dies ist die besser lesbare Alternative zu Methodenüberladungen und hält Ihre API ehrlich, da Sie vermeiden, Überladungen mit nicht intuitiver Reihenfolge zu erzeugen.

Das allgemeine Gesetz der Typoskriptüberladungen lautet:

Wenn Sie die Überlastungssignaturen löschen können und alle Ihre Tests bestanden sind, benötigen Sie keine Typoskriptüberladungen

Normalerweise können Sie dasselbe mit optionalen oder Standardparametern erreichen - oder mit Vereinigungstypen oder mit ein wenig Objektorientierung.

Die eigentliche Frage

Die eigentliche Frage verlangt nach einer Überlastung von:

someMethod(stringParameter: string): void {

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

Jetzt auch in Sprachen, die Überladungen mit separaten Implementierungen unterstützen (Anmerkung:TypeScript-Überladungen teilen sich eine einzige Implementierung) - Programmierer sind Ratschläge, um Konsistenz bei der Bestellung zu gewährleisten.Dies würde die Unterschriften machen:

someMethod(stringParameter: string): void {

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

Der stringParameter ist immer erforderlich, also geht es zuerst.Sie könnten dies als funktionierende Typoskript-Überladung 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 der Typoskriptüberladungen können wir die Überlastungssignaturen löschen und alle unsere Tests bestehen weiterhin.

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

Die eigentliche Frage in der tatsächlichen Reihenfolge

Wenn Sie entschlossen wären, die ursprüngliche Reihenfolge beizubehalten, 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;
    }
  }
}

Das ist eine Menge Verzweigung, um herauszufinden, wo die Parameter abgelegt werden sollen, aber Sie wollten diese Reihenfolge wirklich beibehalten, wenn Sie so weit lesen...aber warten Sie, was passiert, wenn wir das Gesetz der Typoskriptüberladungen anwenden?

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

Schon genug Verzweigungen

Natürlich angesichts der Menge an Typprüfung, die wir durchführen müssen...vielleicht ist die beste Antwort einfach, zwei Methoden zu haben:

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

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

Answer 3

Ich wünschte.Ich möchte auch, dass diese Funktion auch, aber typecript muss mit ungleichem JavaScript interoperabel sein, das nicht überlastete Methoden hat.d. H. Wenn Ihre überlastete Methode aus JavaScript aufgerufen wird, kann es nur an eine Methode-Implementierung abgetastet werden.

Es gibt einige relevante Diskussionen auf CodePlex.z.B.

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

Ich denke immer noch, dass das Typencript alle IF- und Wechseln generieren sollte, sodass wir es nicht tun müssen.

Answer 4

Warum nicht nur Optionale Eigenschaft definierte Schnittstelle als das Funktionsargument ..

Für den Fall in dieser Frage konnte mit einer inline-Schnittstelle, die mit einigen optionalen Eigenschaften definiert ist, nur direkt Code wie etwas unten: generasacodicetagpre.

Da die Überlastung in typecript bereitgestellt wird, wie in anderen Kommentaren genannt, nur eine Liste der verschiedenen Unterschriften der Funktion, ohne entsprechende Implementierungscodes wie andere statische Sprachen zu unterstützen. Die Implementierung muss also noch in nur einem Funktionskörper erfolgen, wodurch die Funktionsnutzung der Funktionsüberlastung in typecript nicht so komfortabel ist wie solche Sprachen, die das echte Überlastungsfunktion unterstützen.

Es gibt jedoch noch viele neue und bequeme Sachen, die in der älteren Programmiersprache nicht verfügbar sind, in der optionale Immobilienunterstützung in einer anonymen Schnittstelle ein solcher Ansatz ist, um die komfortable Zone aus der älteren Funktion überlastend zu treffen, denke ich .

Answer 5

Javascript hat kein Überlastungskonzept.Typecript ist nicht c # oder java.

Sie können jedoch die Überlastung in Mastercript implementieren.

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