Раздел 6.3 спецификации языка TypeScript говорит о перегрузке функций и дает конкретные примеры того, как это реализовать. Однако, если я попробую что-то вроде этого:

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

}

Я получаю ошибку компилятора, указывающую на дубликат идентификатора, даже если параметры функции имеют разные типы. Даже если я добавлю дополнительный параметр ко второй функции createFeatureLayer, я все равно получаю ошибку компилятора. Идеи, пожалуйста.

Это может быть потому, что, когда обе функции скомпилированы в JavaScript, их сигнатура полностью идентична. Поскольку в JavaScript нет типов, в итоге мы создаем две функции, принимающие одинаковое количество аргументов. Таким образом, TypeScript ограничивает нас от создания таких функций.

TypeScript поддерживает перегрузку в зависимости от количества параметров, но шаги, которые необходимо выполнить, немного отличаются, если сравнивать с языками OO. В ответ на другой вопрос SO кто-то объяснил это хорошим примером: перегрузка метода? ,

По сути, мы создаем только одну функцию и несколько объявлений, чтобы TypeScript не выдавал ошибок компиляции. Когда этот код скомпилирован в JavaScript, только конкретная функция будет видна. Поскольку функцию JavaScript можно вызывать, передавая несколько аргументов, она просто работает.

Когда вы перегружаете TypeScript, у вас есть только одна реализация с несколькими сигнатурами.

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

Только три перегрузки распознаются TypeScript как возможные сигнатуры для вызова метода, а не фактическая реализация.

В вашем случае я бы лично использовал два метода с разными именами, так как в параметрах недостаточно общего, что делает возможным, чтобы тело метода нуждалось в большом количестве «если», чтобы решить, что делать.

TypeScript 1.4

Начиная с TypeScript 1.4, вы обычно можете устранить необходимость перегрузки, используя тип объединения. Приведенный выше пример можно лучше выразить, используя:

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

Тип a«или stringили number».

Вы можете объявить перегруженную функцию, объявив функцию как имеющую тип с несколькими сигнатурами вызова:

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

Тогда следующее:

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

Фактическое определение функции должно быть единственным и выполнять соответствующую диспетчеризацию внутри своих аргументов.

Например, используя класс (который может реализовать IFoo, но не обязан):

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

Здесь интересно то, что anyформа скрыта за более конкретно напечатанными переопределениями.

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

Что такое перегрузка функций в целом?

Функция перегрузки или перегрузки методов является возможность создания нескольких функций на одном имени с различными реализациями ( Википедия )

Что такое перегрузка функций в JS?

Эта функция невозможна в JS - последняя определенная функция берется в случае нескольких объявлений:

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

... а в ТС?

Перегрузки являются конструкцией времени компиляции, не влияющей на время выполнения 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

Двойная ошибка реализации возникает, если вы используете приведенный выше код (более безопасный, чем JS). TS выбирает первую фитинговую перегрузку в порядке сверху вниз, поэтому перегрузки сортируются от наиболее специфических к наиболее широким.

Перегрузка метода в TS: более сложный пример

Перегруженные типы методов класса могут использоваться аналогично перегрузке функций:

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

Возможны очень разные перегрузки, так как реализация функции совместима со всеми сигнатурами перегрузки - обеспечивается компилятором.

Больше информации:

• Образец детской площадки
• Что нужно и что нельзя делать при перегрузках

Как замечание к другим, я заметил, что, по крайней мере, как показывает TypeScript, скомпилированный WebPack для Angular 2, вы спокойно получаете overWRITTEN вместо overLOADED методов.

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

Вызов:

myComponent.method()

кажется, выполняет метод с аргументами, молча игнорируя версию без аргументов, с выводом:

with arg

Перегрузка функций в машинописи:

Согласно Википедии (и многим книгам по программированию) определение перегрузки метода / функции следующее:

В некоторых языках программирования перегрузка функций или перегрузка методов - это возможность создавать несколько функций с одинаковыми именами в разных реализациях . Вызовы перегруженной функции будут запускать конкретную реализацию этой функции, соответствующую контексту вызова, позволяя одному вызову функции выполнять различные задачи в зависимости от контекста.

В машинописном тексте мы не можем иметь разные реализации одной и той же функции, которые вызываются в соответствии с количеством и типом аргументов. Это связано с тем, что когда TS компилируется в JS, функции в JS имеют следующие характеристики:

• В определениях функций JavaScript не указываются типы данных для их параметров
• Функции JavaScript не проверяют количество аргументов при вызове

Следовательно, в строгом смысле можно утверждать, что перегрузка функции TS не существует. Однако есть некоторые вещи, которые вы можете сделать в своем коде TS, которые могут идеально имитировать перегрузку функций.

Вот пример:

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

Документация TS вызывает этот метод перегрузкой, и мы в основном поставляли несколько сигнатур методов (описания возможных параметров и типов) компилятору TS. Теперь TS может выяснить, правильно ли мы вызывали нашу функцию во время компиляции, и выдать нам ошибку, если мы вызвали функцию неправильно.