Oppdater for klarhet. Metode overbelastning i Loggfila er en nyttig funksjon i den utstrekning det lar deg lage typedefinisjoner for eksisterende biblioteker med en API som må være representert.

Når du skriver din egen kode, men du kan godt være i stand til å unngå den kognitive belastningen av overbelastning ved hjelp av valgfrie eller standard parametere. Dette er mer lesbar alternativ til metoden overbelastning og også holder API ærlig som du vil unngå å skape overbelastning med unintuitive bestilling.

Den generelle loven om Loggfila overbelaster er:

Hvis du kan slette overbelastning signaturer og alle testene pass, trenger du ikke Loggfila overbelastning

Du kan vanligvis oppnå det samme med valgfrie, eller standardparametere - eller med fagforeningstyper, eller en bit av objektorientering med.

Actual Spørsmål

Selve spørsmålet ber om en overbelastning av:

someMethod(stringParameter: string): void {

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

Nå også i språk som støtter overbelastning med separate implementasjoner (MERK: Loggfila overbelastning dele en enkelt implementering) - programmerere er råd å gi konsistens i bestilling. Dette ville gjøre underskriftene:

someMethod(stringParameter: string): void {

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

Det stringParameterer alltid nødvendig, så det går først. Du kan skrive dette som en arbeider Loggfila overbelastning:

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

Men etter loven om Loggfila overbelastning, kan vi slette overbelastning signaturer og alle våre tester vil fortsatt passere.

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

Actual Spørsmål, i selve Bestill

Hvis du var fast bestemt på å fortsette med den opprinnelige bestillingen, ville overbelastning være:

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

Nå det er mye av forgrening til å regne ut hvor du skal sette parametrene, men du virkelig ønsket å bevare denne rekkefølgen hvis du leser dette langt ... men vent, hva skjer hvis vi bruker loven om Loggfila overbelastning?

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

Nok Forgrening Allerede

Selvfølgelig, gitt mengden av type kontroll vi trenger å gjøre ... kanskje det beste svaret er ganske enkelt å ha to metode:

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

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

Jeg ønsker. Jeg vil ha denne funksjonen også, men Loggfila må være interoperable med utypet Javascript som ikke har overbelastet metoder. dvs. hvis du overbelastet metoden kalles fra Javascript så kan det bare bli sendt til en metode gjennomføring.

Det \ s en få relevante diskusjoner om CodePlex. f.eks

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

Jeg tror fremdeles Loggfila skal generere hele if'ing og bytter slik at vi ikke trenger å gjøre det.

Javascript ikke har noe begrep om overbelastning. Loggfila er ikke C # eller Java.

Men du kan implementere overbelastning i Loggfila.

Les dette innlegget http://www.gyanparkash.in/function-overloading-in-typescript/

Hvorfor ikke bruke valgfri egenskap definert grensesnitt som funksjonsargument ..

For tilfellet i dette spørsmålet, ved hjelp av en innebygd grensesnitt definert med noen valgfrie egenskaper kun kan direkte gjøre koden som noe under:

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

Fordi overbelastning gitt i Loggfila er, som nevnt i andre kommentarer, bare en liste over funksjons ulike signaturer uten støtte tilhørende gjennomførings koder som andre statiske språk. Så implementeringen har fortsatt å gjøres i kun én funksjon kroppen, som gjør bruk av funksjonen overbelastning i Loggfila ikke så komfortabelt som slike språk som støtter den virkelige overbelastning funksjonen.

Men det er fortsatt mange nye og praktiske stuffs gitt i Loggfila som ikke er tilgjengelig i arv programmeringsspråk, hvor valgfri egenskap støtte i en anonym grensesnittet er en slik tilnærming for å møte den komfortable sonen fra arven funksjon overbelastning, tror jeg.

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

}

Jeg tror dette skal fungere