Surcharge de la fonction TypeScript

La section 6.3 de la spécification du langage TypeScript parle de la surcharge des fonctions et donne des exemples concrets sur la manière de l’implémenter. Cependant si j’essaye quelque chose comme ça:

export class LayerFactory { constructor (public styleFactory: Symbology.StyleFactory) { } createFeatureLayer (userContext : Model.UserContext, mapWrapperObj : MapWrapperBase) : any { throw "not implemented"; } createFeatureLayer(layerName : ssortingng, style : any) : any { throw "not implemented"; } } 

Je reçois une erreur de compilation indiquant un identifiant dupliqué alors que les parameters de la fonction sont de types différents. Même si j’ajoute un paramètre supplémentaire à la deuxième fonction createFeatureLayer, j’obtiens toujours une erreur de compilation. Des idées, s’il vous plaît.

Cela peut être dû au fait que, lorsque les deux fonctions sont compilées en JavaScript, leur signature est totalement identique. Comme JavaScript n’a pas de types, nous finissons par créer deux fonctions prenant le même nombre d’arguments. Ainsi, TypeScript nous empêche de créer de telles fonctions.

TypeScript prend en charge la surcharge en fonction du nombre de parameters, mais les étapes à suivre sont légèrement différentes si on les compare aux langages OO. En réponse à une autre question de SO, quelqu’un l’a expliqué avec un bel exemple: surcharge de méthode? .

Fondamentalement, ce que nous faisons, c’est que nous créons une seule fonction et un certain nombre de déclarations afin que TypeScript ne donne pas d’erreurs de compilation. Lorsque ce code est compilé en JavaScript, la fonction concrète seule sera visible. Comme une fonction JavaScript peut être appelée en faisant passer plusieurs arguments, cela fonctionne simplement.

Lorsque vous surchargez TypeScript, vous n’avez qu’une seule implémentation avec plusieurs signatures.

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

Seules les trois surcharges sont reconnues par TypeScript comme des signatures possibles pour un appel de méthode et non l’implémentation réelle.

Dans votre cas, j’utiliserais personnellement deux méthodes avec des noms différents car les parameters ne sont pas assez communs, ce qui fait que le corps de la méthode aura probablement besoin de beaucoup de “si” pour décider quoi faire.

TypeScript 1.4

À partir de TypeScript 1.4, vous pouvez généralement supprimer la nécessité d’une surcharge en utilisant un type d’union. L’exemple ci-dessus peut être mieux exprimé en utilisant:

 myMethod(a: ssortingng | number, b?: ssortingng) { alert(a.toSsortingng()); } 

Le type de a est “soit ssortingng ou number “.

Vous pouvez déclarer une fonction surchargée en déclarant la fonction comme ayant un type possédant plusieurs signatures d’appel:

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

Ensuite:

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

La définition réelle de la fonction doit être singulière et effectuer la répartition appropriée en interne sur ses arguments.

Par exemple, utiliser une classe (qui pourrait implémenter IFoo , mais pas IFoo ):

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

Ce qui est intéressant ici, c’est que la forme any est masquée par les substitutions plus spécifiques.

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

En guise de tête aux autres, j’ai observé qu’au moins comme le manifeste TypScript compilé par WebPack pour Angular 2, vous obtenez tranquillement des méthodes WRITRÉES au lieu des méthodes surchargées.

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

Appel:

 myComponent.method() 

semble exécuter la méthode avec des arguments, ignorant silencieusement la version no-arg, avec une sortie:

 with arg 
  I getting function overload error on visual studio code. **[ts] Duplicate function implementation. function greet(): ssortingng (+1 overload)** function greet():ssortingng{ return 'Hello'; } let message=greet(); console.log(message); function greet(message:ssortingng):ssortingng{ return message; } let newMessage=greet('Hello how are you'); console.log(newMessage); Result : undefined (result of no arg greet method) Hello how are you Please explain why undefined.