Frissítse az egyértelműség kedvéért. Módszer túlterhelés géppel egy hasznos funkció, amennyiben ez lehetővé teszi, hogy típusdefiníciókat meglévő könyvtárak egy API kell képviselni.

Amikor saját kód írásával, bár akkor is el tudják kerülni a kognitív overhead túlterhelés opcionális vagy alapértelmezett paraméterekkel. Ez annál is olvasható alternatív módszer túlterhelés, emellett a API őszinte, mint akkor elkerülhető legyen túlterhelés unintuitive rendelés.

Az általános gyakorlat az írógéppel túlterheli a következő:

Ha törölheti a túlterhelés aláírások és az összes teszt sikeres, akkor nem kell géppel túlterhelés

Akkor általában elérni ugyanezt opcionális, vagy az alapértelmezett paramétereket - vagy szakszervezeti típusú, vagy egy kis tárgy-orientáció.

A tényleges kérdés

A tényleges kérdés kér túlterhelése:

someMethod(stringParameter: string): void {

someMethod(numberParameter: number, stringParameter: string): void {

Most még a nyelv, amely támogatja a túlterhelés külön megvalósítások (megjegyzés: géppel túlterhelés megosztani egy végrehajtás) - programozók tanácsok, hogy összhangot a rendelés. Ez lehetővé tenné az aláírások:

someMethod(stringParameter: string): void {

someMethod(stringParameter: string, numberParameter: number): void {

A stringParametermindig kötelező, ez így megy először. Írhatsz ez egy működő géppel túlterhelés:

someMethod(stringParameter: string): void;
someMethod(stringParameter: string, numberParameter: number): void;
someMethod(stringParameter: string, numberParameter?: number): void {
    if (numberParameter != null) {
        // The number parameter is present...
    }
}

De a következő törvénye géppel túlterhelés, törölhetjük a túlterhelés aláírások és minden tesztben még át.

someMethod(stringParameter: string, numberParameter?: number): void {
    if (numberParameter != null) {
        // The number parameter is present...
    }
}

A tényleges kérdés, az aktuális rendelés

Ha meghatároztuk megmaradnak az eredeti rend, a túlterhelés lenne:

someMethod(stringParameter: string): void;
someMethod(numberParameter: number, stringParameter: string): void;
someMethod(a: string | number, b?: string | number): void {
  let stringParameter: string;
  let numberParameter: number;

  if (typeof a === 'string') {
    stringParameter = a;
  } else {
    numberParameter = a;

    if (typeof b === 'string') {
      stringParameter = b;
    }
  }
}

Most, hogy egy csomó elágazás, hogy dolgozzanak ki, hogy hova tegye a paramétereket, de igazán akarta őrizni ezt a sorrendet, ha ezt olvasod, amennyire ... de várjunk csak, mi történik, ha alkalmazzák a törvény a géppel túlterhelés?

someMethod(a: string | number, b?: string | number): void {
  let stringParameter: string;
  let numberParameter: number;

  if (typeof a === 'string') {
    stringParameter = a;
  } else {
    numberParameter = a;

    if (typeof b === 'string') {
      stringParameter = b;
    }
  }
}

Elég elágazás már

Természetesen, mivel az összeg a típusellenőrzés tennünk kell ... talán a legjobb válasz az, hogy egyszerűen két módszer:

someMethod(stringParameter: string): void {
  this.someOtherMethod(0, stringParameter);
}

someOtherMethod(numberParameter: number, stringParameter: string): void {
  //...
}

Kívánom. Szeretném ezt a lehetőséget is, de géppel kell együttműködjön típustalan JavaScript amely nem túlterhelt módszereket. vagyis Ha a túlterhelt metódust a JavaScript akkor csak kap szállítanak egyik módszer végrehajtását.

Ott \ sa kevés releváns viták codeplex. például

https://typescript.codeplex.com/workitem/617

Még mindig úgy gondolom géppel kell generálni az összes if'ing és kapcsol, így nem lenne szükség rá.

Javascript nincs fogalma a túlterhelés. Géppel nem c # vagy Java.

De akkor végre túlterhelés géppel.

Olvasd el ezt a bejegyzést http://www.gyanparkash.in/function-overloading-in-typescript/

Miért nem használja kötelező tulajdonság definiált interfészen függvényében érv ..

Abban az esetben, ebben a kérdésben, amihez inline felület meghatározott egyes választható tulajdonságokat csak közvetlenül tudta tenni kódot, mintha alább:

class TestClass {

    someMethod(arg: { stringParameter: string, numberParameter?: number }): void {
        let numberParameterMsg = "Variant #1:";
        if (arg.numberParameter) {
            numberParameterMsg = `Variant #2: numberParameter = ${arg.numberParameter},`;
        }
        alert(`${numberParameterMsg} stringParameter = ${arg.stringParameter}`);
    }
}

var testClass = new TestClass();
testClass.someMethod({ stringParameter: "string for v#1" });
testClass.someMethod({ numberParameter: 12345, stringParameter: "string for v#2" });

Mivel túlterhelés feltéve géppel is, ahogy azt mások megjegyzéseire, csak egy lista függvény különböző aláírások nélkül támogató megfelelő végrehajtása kódokat, mint más statikus nyelven. Tehát a végrehajtás továbbra is el kell végezni csak egy funkciót, ami növeli a használat függvényében túlterhelés géppel nem olyan kényelmes, mint olyan támogató nyelvek az igazi túlterhelés funkciót.

Azonban még mindig sok új és kényelmes töm előírt géppel, amely nem áll rendelkezésre régebbi programozási nyelv, ahol nem kötelező tulajdonság támogatás egy névtelen felület egy ilyen megközelítés, hogy megfeleljen a kényelmes terület a régebbi funkció túlterhelés, azt hiszem.

class User{
   name : string;
   age : number;
   constructor(name:string,age:number){
    this.name = name;
    this.age = age;
    console.log("User " +this.name+ " Created")
}
getName(name:string = ""):string{
    if(name != ""){
        return name + " " +this.name;
    }else{
        return this.name;
    }
  }

}

Azt hiszem, ez kell működnie