La sección 6.3 de la especificación del lenguaje TypeScript habla sobre la sobrecarga de funciones y proporciona ejemplos concretos sobre cómo implementar esto. Sin embargo, si intento algo como esto:

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

}

Recibo un error del compilador que indica un identificador duplicado a pesar de que los parámetros de función son de diferentes tipos. Incluso si agrego un parámetro adicional a la segunda función createFeatureLayer, sigo obteniendo un error del compilador. Ideas, por favor.

Esto puede deberse a que, cuando ambas funciones se compilan en JavaScript, su firma es totalmente idéntica. Como JavaScript no tiene tipos, terminamos creando dos funciones con la misma cantidad de argumentos. Entonces, TypeScript nos restringe de crear tales funciones.

TypeScript admite la sobrecarga en función del 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 compilación. Cuando este código se compila en JavaScript, solo se verá la función concreta. Como se puede invocar una función de JavaScript pasando varios argumentos, simplemente funciona.

Cuando sobrecarga en TypeScript, solo tiene una implementación con múltiples firmas.

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

TypeScript reconoce solo las tres sobrecargas como posibles firmas para una llamada a método, no la implementación real.

En su caso, personalmente usaría dos métodos con nombres diferentes, ya que no hay suficientes puntos en común en los parámetros, lo que hace que sea probable que el cuerpo del método tenga que 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 expresar mejor usando:

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

El tipo de aes "cualquiera stringo 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;
    }
}

Entonces 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, usando una clase (que podría implementarse IFoo, pero no tiene que hacerlo):

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 interesante aquí es que el anyformulario está oculto por las anulaciones más específicamente escritas.

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

¿Qué es la sobrecarga de funciones en general?

La sobrecarga de funciones o la sobrecarga de métodos es la capacidad de crear múltiples funciones del mismo nombre con diferentes implementaciones ( Wikipedia )

¿Qué es la sobrecarga de funciones en JS?

Esta característica no es posible en JS: la última función definida se toma en caso de declaraciones múltiples:

function foo(a1, a2) { return `${a1}, ${a2}` }
function foo(a1) { return `${a1}` } // replaces above `foo` declaration
foo(42, "foo") // "42"

... y en TS?

Las sobrecargas son una construcción en tiempo de compilación sin impacto en el tiempo de ejecución de JS:

function foo(s: string): string // overload #1 of foo
function foo(s: string, n: number): number // overload #2 of foo
function foo(s: string, n?: number): string | number {/* ... */} // foo implementation

Se activa un error de implementación duplicado, si utiliza el código anterior (más seguro que JS). TS elige la primera sobrecarga de ajuste en orden de arriba hacia abajo, por lo que las sobrecargas se ordenan de la más específica a la más amplia.

Método de sobrecarga en TS: un ejemplo más complejo

Los tipos de métodos de clase sobrecargados se pueden usar de manera similar para sobrecargar la función:

class LayerFactory {
    createFeatureLayer(a1: string, a2: number): string
    createFeatureLayer(a1: number, a2: boolean, a3: string): number
    createFeatureLayer(a1: string | number, a2: number | boolean, a3?: string)
        : number | string { /*... your implementation*/ }
}

const fact = new LayerFactory()
fact.createFeatureLayer("foo", 42) // string
fact.createFeatureLayer(3, true, "bar") // number

Las sobrecargas muy diferentes son posibles, ya que la implementación de la función es compatible con todas las firmas de sobrecarga, aplicada por el compilador.

Más información:

• Muestra del patio
• Qué hacer y qué no hacer para sobrecargas

Como aviso a los demás, he observado que, al menos según lo manifestado por TypeScript compilado por WebPack para Angular 2, silenciosamente se ESCRIBE 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 sin argumentos, con salida:

with arg

Sobrecarga de funciones en mecanografiado:

Según Wikipedia, (y muchos libros de programación) la definición de sobrecarga de método / función es la siguiente:

En algunos lenguajes de programación, la sobrecarga de funciones o la sobrecarga de métodos es la capacidad de crear múltiples funciones del mismo nombre con diferentes implementaciones . Las llamadas a una función sobrecargada ejecutarán una implementación específica de esa función adecuada al contexto de la llamada, permitiendo que una llamada de función realice diferentes tareas dependiendo del contexto.

En typecript no podemos tener implementaciones diferentes de la misma función que se llaman de acuerdo con el número y tipo de argumentos. Esto se debe a que cuando TS se compila a JS, las funciones en JS tienen las siguientes características:

• Las definiciones de funciones de JavaScript no especifican tipos de datos para sus parámetros
• Las funciones de JavaScript no comprueban el número de argumentos cuando se llama

Por lo tanto, en sentido estricto, se podría argumentar que la sobrecarga de la función TS no existe. Sin embargo, hay cosas que puede hacer dentro de su código TS que pueden imitar perfectamente la sobrecarga de funciones.

Aquí hay un ejemplo:

function add(a: number, b: number, c: number): number;
function add(a: number, b: number): any;
function add(a: string, b: string): any;

function add(a: any, b: any, c?: any): any {
  if (c) {
    return a + c;
  }
  if (typeof a === 'string') {
    return `a is ${a}, b is ${b}`;
  } else {
    return a + b;
  }
}

Los documentos de TS llaman a este método sobrecarga, y lo que básicamente hicimos fue proporcionar firmas de métodos múltiples (descripciones de posibles parámetros y tipos) al compilador de TS. Ahora TS puede descubrir si llamamos a nuestra función correctamente durante el tiempo de compilación y darnos un error si llamamos a la función incorrectamente.