Werk voor de duidelijkheid. Methode overbelasting met de schrijfmachine is een nuttige functie voor zover het u toestaat om typedefinities beheren voor bestaande bibliotheken met een API die moet worden vertegenwoordigd.

Bij het schrijven van uw eigen code, hoewel, kan je goed in staat zijn om de cognitieve overhead van overbelasting met behulp van optionele of standaard parameters te voorkomen. Dit is het beter leesbaar alternatief voor de methode overbelasting en houdt ook uw API eerlijk als je voorkomen dat overbelasting met unintuitive bestellen.

De algemene wet van typoscript overbelasting is:

Als u de overbelasting handtekeningen kunnen verwijderen en al uw tests moeten doorstaan, heb je niet nodig typoscript overbelasting

Meestal kunt bereiken hetzelfde met optionele of standaard parameters - of met types unie, of met een beetje van object-oriëntatie.

De werkelijke vraag

De werkelijke vraag vraagt ​​om een ​​overbelasting van:

someMethod(stringParameter: string): void {

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

Nu zelfs in talen die overbelasting met aparte implementaties (let op: typoscript overbelasting delen een enkele implementatie) ondersteuning - programmeurs zijn adviezen aan consistentie in bestelling. Dit zou de handtekeningen:

someMethod(stringParameter: string): void {

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

Het stringParameteris altijd vereist, dus het eerste gaat. U kon dit schrijven als een werkende typoscript overload:

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

Maar naar aanleiding van de wet van typoscript overbelasting, kunnen we de overbelasting handtekeningen te verwijderen en al onze tests zal nog passeren.

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

De werkelijke vraag, In de Actual Order

Als u waren vastbesloten om vol te houden met de oorspronkelijke volgorde, zou de overbelasting zijn:

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

Nu is dat een veel vertakking uit te werken waar de parameters te zetten, maar je echt wilde deze orde te handhaven als je dit leest ver ... maar wacht, wat gebeurt er als we de wet van typoscript overbelasting van toepassing zijn?

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

Genoeg Branching Reeds

Natuurlijk, gezien de hoeveelheid type checking we moeten doen ... misschien het beste antwoord is gewoon om twee methode te hebben:

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

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

Mocht ik willen. Ik wil dat deze functie ook maar typoscript moet interoperabel met ongetypeerde JavaScript die niet overbelast methoden hoeft te zijn. ie Als uw overloaded methode wordt aangeroepen vanuit JavaScript dan kan het alleen maar verzonden naar een methode implementatie.

Er \ s een paar relevante discussies op CodePlex. bv

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

Ik denk nog steeds typoscript moeten alle if'ing genereren en het schakelen zodat we niet hoeven te doen.

Javascript heeft geen concept van de overbelasting te hebben. Typescript is niet C # of Java.

Maar u kunt implementeren overbelasting in Typescript.

Lees dit bericht http://www.gyanparkash.in/function-overloading-in-typescript/

Waarom niet te gebruiken optionele eigenschap gedefinieerde interface als de functie argument ..

Voor het geval deze vraag, met behulp van een inline-interface gedefinieerd met een aantal optionele eigenschappen kon alleen rechtstreeks code als iets hieronder te maken:

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

Omdat overbelasten voorzien in typoscript is, zoals vermeld in anderen opmerkingen, maar een lijst van verschillende handtekeningen functie zonder de ondersteuning van overeenkomstige toepassing codes zoals andere statische talen. Dus de uitvoering moet nog worden gedaan in slechts één functie lichaam, dat het gebruik van de functie overbelasting in Typescript niet zo comfortabel als zodanig talen ondersteunen van de echte overbelasting functie maakt.

Echter, er is nog steeds veel nieuwe en handige levensmiddelen voorzien met de schrijfmachine die niet beschikbaar zijn in legacy programmeertaal, waar de optionele eigenschap ondersteuning in een anonieme interface is een dergelijke aanpak de comfortabele zone van de legacy functie overbelasting te ontmoeten is, denk ik.

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

}

Ik denk dat dit zou moeten werken