Sobrecarga de función de TypeScript

La Sección 6.3 de la especificación de lenguaje de TypeScript habla sobre la sobrecarga de funciones y brinda ejemplos concretos sobre cómo implementar esto. Sin embargo, si bash algo así:

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

Aparece un error del comstackdor que indica un identificador duplicado aunque los parámetros de la función son de tipos diferentes. Incluso si agrego un parámetro adicional a la segunda función createFeatureLayer, sigo teniendo un error de comstackción. Ideas, por favor.

Esto puede deberse a que, cuando ambas funciones se comstackn en JavaScript, su firma es totalmente idéntica. Como JavaScript no tiene tipos, terminamos creando dos funciones teniendo el mismo número de argumentos. Entonces, TypeScript nos impide crear tales funciones.

TypeScript admite la sobrecarga según el número de parámetros, pero los pasos a seguir son un poco diferentes si los comparamos con los lenguajes OO. En respuesta a otra pregunta de SO, alguien lo explicó con un buen ejemplo: Sobrecarga de método. .

Básicamente, lo que estamos haciendo es crear una sola función y varias declaraciones para que TypeScript no dé errores de comstackción. Cuando este código se comstack en JavaScript, la función concreta por sí sola será visible. Como se puede invocar una función de JavaScript pasando múltiples argumentos, simplemente funciona.

Cuando sobrecarga en TypeScript, solo tiene una implementación con varias firmas.

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

Solo las tres sobrecargas son reconocidas por TypeScript como posibles firmas para una llamada de método, no la implementación real.

En su caso, personalmente usaría dos métodos con diferentes nombres, ya que no hay suficientes elementos comunes en los parámetros, lo que hace probable que el cuerpo del método necesite tener muchos “si” para decidir qué hacer.

TypeScript 1.4

A partir de TypeScript 1.4, normalmente puede eliminar la necesidad de una sobrecarga utilizando un tipo de unión. El ejemplo anterior se puede express mejor usando:

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

El tipo de a es ” string o number “.

Puede declarar una función sobrecargada declarando que la función tiene un tipo que tiene múltiples firmas de invocación:

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

Luego lo siguiente:

 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 definición real de la función debe ser singular y realizar el despacho apropiado internamente en sus argumentos.

Por ejemplo, usar una clase (que podría implementar IFoo , pero no tiene por qué):

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

Lo que es interesante aquí es que any formulario está oculto por las anulaciones más específicas.

 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 

Como una advertencia a otros, he observado que al menos como se manifiesta por TypeScript comstackdo por WebPack para Angular 2, en silencio se sobreescribe en lugar de métodos sobrecargados.

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

Vocación:

 myComponent.method() 

parece ejecutar el método con argumentos, ignorando silenciosamente la versión no-arg, con salida:

 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.