Sovraccarico della funzione TypeScript

La sezione 6.3 delle specifiche del linguaggio TypeScript parla dell’overloading delle funzioni e fornisce esempi concreti su come implementarle. Comunque se provo qualcosa del genere:

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

Ricevo un errore del compilatore che indica l’identificativo duplicato anche se i parametri di funzione sono di tipi diversi. Anche se aggiungo un parametro aggiuntivo alla seconda funzione createFeatureLayer, ricevo comunque un errore del compilatore. Idee, per favore

Ciò può essere dovuto al fatto che, quando entrambe le funzioni sono compilate su JavaScript, la loro firma è totalmente identica. Siccome JavaScript non ha tipi, finiamo per creare due funzioni con lo stesso numero di argomenti. Quindi, TypeScript ci impedisce di creare tali funzioni.

TypeScript supporta l’overload in base al numero di parametri, ma i passaggi da seguire sono leggermente diversi se confrontiamo con le lingue OO. In risposta ad un’altra domanda SO, qualcuno lo ha spiegato con un bell’esempio: overloading del metodo? .

Fondamentalmente, quello che stiamo facendo è che stiamo creando solo una funzione e un numero di dichiarazioni in modo che TypeScript non dia errori di compilazione. Quando questo codice è compilato su JavaScript, la funzione concreta da solo sarà visibile. Poiché una funzione JavaScript può essere chiamata passando più argomenti, funziona semplicemente.

Quando sovraccarichi in TypeScript, hai solo un’implementazione con più firme.

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

Solo i tre overload sono riconosciuti da TypeScript come possibili firme per una chiamata al metodo, non l’effettiva implementazione.

Nel tuo caso, utilizzerei personalmente due metodi con nomi diversi perché non c’è abbastanza comunanza nei parametri, il che rende probabile che il corpo del metodo abbia bisogno di molti “se” per decidere cosa fare.

TypeScript 1.4

A partire da TypeScript 1.4, in genere è ansible rimuovere la necessità di un overload utilizzando un tipo di unione. L’esempio sopra può essere meglio express usando:

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

Il tipo di a è ” string o number “.

È ansible dichiarare una funzione sovraccaricata dichiarando che la funzione ha un tipo con più firme di chiamata:

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

Quindi il seguente:

 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 

La definizione effettiva della funzione deve essere singolare ed eseguire il dispacciamento appropriato internamente sui suoi argomenti.

Ad esempio, utilizzando una class (che potrebbe implementare IFoo , ma non deve):

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

Ciò che è interessante qui è che any forma è nascosta dalle sostituzioni più tipizzate.

 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 

Come testa agli altri, ho osservato che almeno come manifestato da TypeScript compilato da WebPack per Angular 2, si ottiene tranquillamente overWRITTEN invece dei metodi overLOADED.

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

Calling:

 myComponent.method() 

sembra eseguire il metodo con argomenti, ignorando silenziosamente la versione no-arg, con output:

 with arg 
  I getting function overload error on visual studio code. **[ts] Duplicate function implementation. function greet(): string (+1 overload)** function greet():string{ return 'Hello'; } let message=greet(); console.log(message); function greet(message:string):string{ 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.