Gibt es eine Möglichkeit, Methoden in TypeScript 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 Überladungshacks 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);
javascript
typescript
operator-overloading
Void-995
quelle
quelle
Antworten:
Gemäß der Spezifikation unterstützt TypeScript das Überladen von Methoden, ist jedoch recht umständlich und enthält viele manuelle Arbeiten zur Überprüfung der Parametertypen. Ich denke, das liegt hauptsächlich daran, dass das Überladen von Methoden in einfachem JavaScript am nächsten kommt, wenn auch überprüft wird und TypeScript versucht, die tatsächlichen Methodenkörper nicht zu ändern, um unnötige Kosten für die Laufzeitleistung zu vermeiden.
Wenn ich es richtig verstehe, müssen Sie zuerst eine Methodendeklaration für jede der Überladungen und dann eine Methodenimplementierung schreiben , die ihre Argumente überprüft, um zu entscheiden, welche Überladung aufgerufen wurde. Die Signatur der Implementierung muss mit allen Überlastungen kompatibel sein.
quelle
Aus Gründen der Übersichtlichkeit aktualisieren. Das Überladen von Methoden in TypeScript ist insofern eine nützliche Funktion, als Sie 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 erstellen.
Das allgemeine Gesetz für TypeScript-Überladungen lautet:
Normalerweise können Sie dasselbe mit optionalen oder Standardparametern erreichen - oder mit Vereinigungstypen oder mit etwas Objektorientierung.
Die eigentliche Frage
Die eigentliche Frage verlangt nach einer Überlastung von:
Selbst in Sprachen, die Überladungen mit separaten Implementierungen unterstützen (Hinweis: TypeScript-Überladungen teilen sich eine einzige Implementierung), empfehlen Programmierer, eine einheitliche Reihenfolge zu gewährleisten. Dies würde die Unterschriften machen:
Das
stringParameter
ist immer erforderlich, also geht es zuerst. Sie könnten dies als funktionierende TypeScript-Überladung schreiben:Nach dem Gesetz der TypeScript-Überladungen können wir die Überladungssignaturen löschen und alle unsere Tests werden weiterhin bestanden.
Die tatsächliche Frage in der tatsächlichen Reihenfolge
Wenn Sie entschlossen wären, die ursprüngliche Bestellung beizubehalten, wären die Überlastungen:
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 TypeScript-Überladungen anwenden?
Genug Verzweigung schon
Angesichts der Menge an Typprüfungen, die wir durchführen müssen, ist die beste Antwort vielleicht einfach, zwei Methoden zu haben:
quelle
number
Parameter das zweite Argument und optional wäre. TypeScript unterstützt keine "richtigen" Methodenüberladungen - aber selbst die C # -Welt bewegt sich weg von Überladungen hin zu optionalen Parametern, da dies in vielen Fällen zu besser lesbarem Code führt.if (typeof numberParameter != 'undefined')
, richtig;)!==
, um Jonglieren zu vermeiden.Ich wünsche. Ich möchte diese Funktion auch, aber TypeScript muss mit untypisiertem JavaScript kompatibel sein, das keine überladenen Methoden hat. dh Wenn Ihre überladene Methode von JavaScript aufgerufen wird, kann sie nur an eine Methodenimplementierung gesendet werden.
Es gibt nur wenige relevante Diskussionen über Codeplex. z.B
https://typescript.codeplex.com/workitem/617
Ich denke immer noch, dass TypeScript das gesamte If'ing und Switching generieren sollte, damit wir es nicht tun müssen.
quelle
Warum nicht die optionale eigenschaftsdefinierte Schnittstelle als Funktionsargument verwenden?
Für den Fall in dieser Frage kann die Verwendung einer Inline-Schnittstelle, die nur mit einigen optionalen Eigenschaften definiert ist, direkt Code wie folgt erzeugen:
Da das in TypeScript bereitgestellte Überladen, wie in den Kommentaren anderer erwähnt, nur eine Liste der verschiedenen Signaturen der Funktion ist, ohne entsprechende Implementierungscodes wie andere statische Sprachen zu unterstützen. Die Implementierung muss also immer noch in nur einem Funktionskörper erfolgen, was die Verwendung der Funktionsüberladung in Typescript nicht so komfortabel macht wie solche Sprachen, die die eigentliche Überladungsfunktion unterstützen.
Es gibt jedoch immer noch viele neue und praktische Dinge in Typoskript, die nicht in der Legacy-Programmiersprache verfügbar sind, wo die optionale Eigenschaftsunterstützung in einer anonymen Schnittstelle ein solcher Ansatz ist, um die komfortable Zone aufgrund der Überlastung der Legacy-Funktionen zu erfüllen, denke ich.
quelle
Wenn es viele Variationen von Methodenüberladungen gibt, besteht eine andere Möglichkeit darin, eine Klasse mit all Ihren Argumenten zu erstellen. Sie können also nur die gewünschten Parameter in beliebiger Reihenfolge übergeben.
Sie können auch einen Konstruktor mit Standardwerten erstellen und / oder einige obligatorische Argumente übergeben. Dann benutze einfach so:
quelle
Javascript hat kein Konzept der Überladung. Typoskript ist nicht c # oder Java.
Sie können jedoch eine Überladung in Typescript implementieren.
Lesen Sie diesen Beitrag http://www.gyanparkash.in/function-overloading-in-typescript/
quelle