Méthode surchargée?

Question

Existe-t-il un moyen de surcharger une méthode en langage TypeScript?

Je veux réaliser quelque chose comme ça:

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

Voici un exemple de ce que je ne veux pas faire (je déteste vraiment cette partie de la surcharge de bidouille dans JS):

 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

Selon les spécifications, la Machine prend en charge la surcharge de méthode, mais c'est assez difficile et beaucoup de travail manuel de la vérification des types de paramètres. Je pense que c'est surtout parce que le plus proche que vous pouvez obtenir à la surcharge de méthode dans la plaine du JavaScript comprend que la vérification de trop et Tapuscrit essaie de ne pas modifier le corps de méthode pour éviter les performances d'exécution de coût.

Si je comprends bien, vous devez d'abord écrire une déclaration de méthode pour chacune des surcharges et puis une implémentation de la méthode qui vérifie ses arguments pour décider qui surcharge a été appelé. La signature de la mise en œuvre se doit d'être compatible avec tous les surcharges.

class TestClass {
    someMethod(stringParameter: string): void;
    someMethod(numberParameter: number, stringParameter: string): void;

    someMethod(stringOrNumberParameter: any, stringParameter?: string): void {
        if (stringOrNumberParameter && typeof stringOrNumberParameter == "number")
            alert("Variant #2: numberParameter = " + stringOrNumberParameter + ", stringParameter = " + stringParameter);
        else
            alert("Variant #1: stringParameter = " + stringOrNumberParameter);
    }
}

Answer 2

Vous pourrez peut-être obtenir ce dont vous avez besoin à l’aide de paramètres facultatifs:

 class TestClass {
    someMethod(stringParameter: string, secondParameter: string = ""): void {
        alert("The parameters were " + stringParameter + " and " + secondParameter);
    }
}

var testClass = new TestClass();
testClass.someMethod("String 1");
testClass.someMethod("String 1", "String 2");
 

J'ai utilisé deux chaînes, mais l'une pourrait être un nombre tout aussi facilement.

Answer 3

Je le souhaite. Je veux cette fonctionnalité aussi, mais la Machine doit être interopérable avec typée JavaScript qui n'a pas de méthodes surchargées. par exemple, Si votre méthode surchargée est appelé à partir de JavaScript alors il ne peut obtenir expédiés à une méthode de mise en œuvre.

Il y\s un peu les discussions sur codeplex. par exemple

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

Je pense toujours que la Machine devrait générer tous les cas avec et de commutation de sorte que nous n'aurions pas besoin de le faire.