A Seção 6.3 da especificação da linguagem TypeScript fala sobre sobrecarga de funções e fornece exemplos concretos de como implementar isso. No entanto, se eu tentar algo assim:

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

}

Eu recebo um erro do compilador indicando o identificador duplicado, embora os parâmetros de função sejam de tipos diferentes. Mesmo se eu adicionar um parâmetro adicional à segunda função createFeatureLayer, ainda recebo um erro do compilador. Idéias, por favor.

Isso pode ocorrer porque, quando as duas funções são compiladas para JavaScript, sua assinatura é totalmente idêntica. Como o JavaScript não possui tipos, acabamos criando duas funções com o mesmo número de argumentos. Portanto, o TypeScript nos impede de criar essas funções.

O TypeScript suporta sobrecarga com base no número de parâmetros, mas as etapas a serem seguidas são um pouco diferentes se compararmos às linguagens OO. Em resposta a outra pergunta do SO, alguém explicou com um bom exemplo: Sobrecarga de método? .

Basicamente, o que estamos fazendo é criar apenas uma função e várias declarações para que o TypeScript não dê erros de compilação. Quando esse código é compilado para JavaScript, a função concreta sozinha fica visível. Como uma função JavaScript pode ser chamada passando vários argumentos, ela simplesmente funciona.

Quando você sobrecarrega no TypeScript, você tem apenas uma implementação com várias assinaturas.

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

Somente as três sobrecargas são reconhecidas pelo TypeScript como possíveis assinaturas para uma chamada de método, não a implementação real.

No seu caso, eu pessoalmente usaria dois métodos com nomes diferentes, pois não há elementos comuns suficientes nos parâmetros, o que torna provável que o corpo do método precise ter muitos "ifs" para decidir o que fazer.

TypeScript 1.4

A partir do TypeScript 1.4, você normalmente pode remover a necessidade de sobrecarga usando um tipo de união. O exemplo acima pode ser melhor expresso usando:

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

O tipo de aé "um stringou number".

Você pode declarar uma função sobrecarregada declarando a função como tendo um tipo que possui várias assinaturas de chamada:

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

Então o seguinte:

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

A definição real da função deve ser singular e executar o despacho apropriado internamente em seus argumentos.

Por exemplo, usando uma classe (que pode implementar IFoo, mas não precisa):

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

O interessante aqui é que o anyformulário está oculto pelas substituições digitadas mais especificamente.

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

O que é sobrecarga de função em geral?

Sobrecarga de função ou sobrecarga de método é a capacidade de criar várias funções com o mesmo nome com diferentes implementações ( Wikipedia )

O que é sobrecarga de função em JS?

Esse recurso não é possível no JS - a última função definida é utilizada no caso de várias declarações:

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

... e em TS?

Sobrecargas são uma construção em tempo de compilação sem impacto no tempo de execução 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

Um erro de implementação duplicado é acionado, se você usar o código acima (mais seguro que o JS). O TS escolhe a primeira sobrecarga de montagem na ordem descendente, para que as sobrecargas sejam classificadas da mais específica à mais ampla.

Sobrecarga de método no TS: um exemplo mais complexo

Os tipos de métodos de classe sobrecarregados podem ser usados ​​de maneira semelhante à sobrecarga de funções:

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

As sobrecargas muito diferentes são possíveis, pois a implementação da função é compatível com todas as assinaturas de sobrecarga - impostas pelo compilador.

Mais informações:

• Amostra para parque infantil
• O que fazer e o que não fazer por sobrecargas

Como aviso aos outros, observei que, pelo menos como manifestado pelo TypeScript compilado pelo WebPack para Angular 2, você silenciosamente supera os métodos WRITTEN em vez de overLOADED.

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

A ligar:

myComponent.method()

parece executar o método com argumentos, ignorando silenciosamente a versão sem argumento, com saída:

with arg

Sobrecarga de função em texto datilografado:

Segundo a Wikipedia, (e muitos livros de programação), a definição de sobrecarga de método / função é a seguinte:

Em algumas linguagens de programação, sobrecarga de função ou sobrecarga de método é a capacidade de criar várias funções com o mesmo nome com implementações diferentes . As chamadas para uma função sobrecarregada executarão uma implementação específica dessa função apropriada ao contexto da chamada, permitindo que uma chamada de função execute tarefas diferentes, dependendo do contexto.

No texto datilografado, não podemos ter implementações diferentes da mesma função que são chamadas de acordo com o número e o tipo de argumentos. Isso ocorre porque quando o TS é compilado para JS, as funções em JS têm as seguintes características:

• As definições de função JavaScript não especificam tipos de dados para seus parâmetros
• As funções JavaScript não verificam o número de argumentos quando chamados

Portanto, em sentido estrito, pode-se argumentar que a sobrecarga da função TS não existe. No entanto, existem coisas que você pode fazer no seu código TS que podem imitar perfeitamente a sobrecarga de funções.

Aqui está um exemplo:

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

Os documentos do TS chamam esse método de sobrecarga, e o que basicamente fizemos foi fornecer várias assinaturas de métodos (descrições de possíveis parâmetros e tipos) ao compilador TS. Agora, o TS pode descobrir se chamamos nossa função corretamente durante o tempo de compilação e nos dar um erro se chamarmos a função incorretamente.