Bagian 6.3 dari spesifikasi bahasa TypeScript berbicara tentang fungsi yang berlebihan dan memberikan contoh nyata tentang bagaimana mengimplementasikan ini. Namun jika saya mencoba sesuatu seperti ini:

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

}

Saya mendapatkan kesalahan kompiler yang menunjukkan pengidentifikasi duplikat meskipun parameter fungsi dari tipe yang berbeda. Bahkan jika saya menambahkan parameter tambahan ke fungsi createFeatureLayer kedua, saya masih mendapatkan kesalahan kompiler. Gagasan, silakan.

Ini mungkin karena, ketika kedua fungsi dikompilasi dengan JavaScript, tanda tangannya sama sekali identik. Karena JavaScript tidak memiliki jenis, kami akhirnya membuat dua fungsi dengan jumlah argumen yang sama. Jadi, TypeScript membatasi kita dari membuat fungsi-fungsi seperti itu.

TypeScript mendukung overloading berdasarkan jumlah parameter, tetapi langkah-langkah yang harus diikuti sedikit berbeda jika kita dibandingkan dengan bahasa OO. Dalam menjawab pertanyaan SO lainnya, seseorang menjelaskannya dengan contoh yang bagus: Metode overloading? .

Pada dasarnya, apa yang kita lakukan adalah, kita hanya menciptakan satu fungsi dan sejumlah deklarasi sehingga TypeScript tidak memberikan kesalahan kompilasi. Ketika kode ini dikompilasi ke JavaScript, fungsi konkret saja akan terlihat. Sebagai fungsi JavaScript dapat dipanggil dengan melewati beberapa argumen, itu hanya berfungsi.

Ketika Anda kelebihan dalam TypeScript, Anda hanya memiliki satu implementasi dengan beberapa tanda tangan.

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

Hanya tiga kelebihan yang dikenali oleh TypeScript sebagai tanda tangan yang mungkin untuk pemanggilan metode, bukan implementasi yang sebenarnya.

Dalam kasus Anda, saya secara pribadi akan menggunakan dua metode dengan nama yang berbeda karena tidak ada cukup kesamaan dalam parameter, yang memungkinkan badan metode perlu memiliki banyak "seandainya" untuk memutuskan apa yang harus dilakukan.

TypeScript 1.4

Pada TypeScript 1.4, Anda biasanya dapat menghapus kebutuhan untuk kelebihan menggunakan tipe serikat. Contoh di atas dapat diekspresikan lebih baik menggunakan:

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

Jenisnya aadalah "salah stringatau number".

Anda dapat mendeklarasikan fungsi kelebihan beban dengan mendeklarasikan fungsi tersebut memiliki tipe yang memiliki banyak tanda tangan permohonan:

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

Maka berikut ini:

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

Definisi aktual dari fungsi harus tunggal dan melakukan pengiriman yang tepat secara internal pada argumennya.

Misalnya, menggunakan kelas (yang bisa mengimplementasikan IFoo, tetapi tidak harus):

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

Yang menarik di sini adalah bahwa anyformulir disembunyikan oleh penimpaan diketik lebih spesifik.

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

Apakah fungsi kelebihan beban secara umum?

Fungsi overloading atau metode overloading adalah kemampuan untuk membuat beberapa fungsi dari nama yang sama dengan implementasi yang berbeda ( Wikipedia )

Apakah fungsi kelebihan beban di JS?

Fitur ini tidak dimungkinkan dalam JS - fungsi yang didefinisikan terakhir diambil jika ada beberapa deklarasi:

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

... dan di TS?

Overload adalah konstruk waktu kompilasi tanpa dampak pada runtime 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

Kesalahan implementasi duplikat dipicu, jika Anda menggunakan kode di atas (lebih aman daripada JS). TS memilih overload fitting pertama dalam urutan top-down, sehingga overload diurutkan dari yang paling spesifik ke yang paling luas.

Metode overloading di TS: contoh yang lebih kompleks

Tipe metode kelas kelebihan beban dapat digunakan dengan cara yang mirip dengan fungsi kelebihan beban:

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

Overload yang sangat berbeda dimungkinkan, karena implementasi fungsi kompatibel untuk semua tanda tangan overload - diberlakukan oleh kompiler.

Lebih banyak info:

• Sampel taman bermain
• Do's and Don'ts for overloads

Sebagai kepala ke orang lain, saya telah menyadari bahwa setidaknya sebagaimana dimanifestasikan oleh TypeScript dikompilasi oleh WebPack untuk Angular 2, Anda diam-diam mendapatkan overWRITTEN alih-alih metode overLOADED.

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

Panggilan:

myComponent.method()

tampaknya mengeksekusi metode dengan argumen, dengan diam-diam mengabaikan versi no-arg, dengan output:

with arg

Fungsi overload dalam naskah:

Menurut Wikipedia, (dan banyak buku pemrograman) definisi overloading metode / fungsi adalah sebagai berikut:

Dalam beberapa bahasa pemrograman, kelebihan fungsi atau kelebihan metode adalah kemampuan untuk membuat beberapa fungsi dengan nama yang sama dengan implementasi yang berbeda . Panggilan ke fungsi yang kelebihan beban akan menjalankan implementasi spesifik dari fungsi yang sesuai dengan konteks panggilan, memungkinkan satu panggilan fungsi untuk melakukan tugas yang berbeda tergantung pada konteksnya.

Dalam naskah, kita tidak bisa memiliki implementasi yang berbeda dari fungsi yang sama yang dipanggil sesuai dengan jumlah dan jenis argumen. Ini karena ketika TS dikompilasi ke JS, fungsi-fungsi di JS memiliki karakteristik berikut:

• Definisi fungsi JavaScript tidak menentukan tipe data untuk parameternya
• Fungsi JavaScript tidak memeriksa jumlah argumen saat dipanggil

Oleh karena itu, dalam arti yang ketat, orang dapat berargumen bahwa kelebihan fungsi TS tidak ada. Namun, ada beberapa hal yang dapat Anda lakukan dalam kode TS Anda yang dapat dengan sempurna meniru fungsi yang berlebihan.

Berikut ini sebuah contoh:

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 docs menyebut metode ini kelebihan beban, dan yang pada dasarnya kami lakukan adalah memasok beberapa tanda tangan metode (deskripsi parameter dan tipe yang mungkin) ke kompiler TS. Sekarang TS dapat mengetahui apakah kita memanggil fungsi kita dengan benar selama waktu kompilasi dan memberi kita kesalahan jika kita menyebut fungsi tersebut dengan tidak benar.