Actualizare pentru claritate. Metoda supraîncărcării dactilografiat este o caracteristică utilă în măsura în care vă permite să creați definiții de tip pentru bibliotecile existente cu un API care trebuie să fie reprezentate.

Când scrieți propriul cod, deși, ați putea fi bine capabil de a evita suprasarcina cognitivă a suprasarcinilor cu ajutorul parametrilor opționali sau implicite. Aceasta este alternativa mai ușor de citit la suprasarcini metoda și, de asemenea, păstrează API-ul onest ca vei evita crearea de suprasarcini cu ordonarea unintuitive.

Legea generală dactilografiate supraîncarcă este:

Dacă puteți șterge semnăturile de suprasarcină și toate testele dumneavoastră trec, nu aveți nevoie de suprasarcini typescript

Puteți obține, de obicei, același lucru cu parametrii opționali, sau standard - sau cu tipuri de unire, sau cu un pic de obiect-orientare.

Problema actuală

Problema reală cere o supraîncărcare de:

someMethod(stringParameter: string): void {

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

Acum, chiar și în limbi care acceptă suprasarcini cu implementări separate (nota: suprasarcini typescript împart o singură implementare) - programatori sunt sfaturi pentru a oferi coerență în ordonarea. Acest lucru ar face semnăturile:

someMethod(stringParameter: string): void {

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

stringParameterEste întotdeauna necesar, asa ca merge mai întâi. Ai putea scrie acest lucru ca o supraîncărcare de lucru typescript:

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

Dar, ca urmare legea suprasarcini typescript, putem șterge semnăturile de suprasarcină și toate testele noastre vor trece în continuare.

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

Problema actuală, în ordinea actuală

Dacă au fost determinate să persiste cu ordinea inițială, suprasarcinilor ar fi:

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

Acum, că o mulțime de ramificare pentru a lucra în cazul în care pentru a pune parametrii, dar ai vrut cu adevărat să păstreze această ordine dacă citiți acest departe ... dar stai, ce se întâmplă dacă aplicăm legea suprasarcini typescript?

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

Destul de ramificare Deja

Desigur, având în vedere cantitatea de tip verificare trebuie să facem ... poate cel mai bun răspuns este pur și simplu de a avea două metode:

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

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

Eu doresc. Vreau aceasta facilitate prea, dar trebuie typescript să fie interoperabile cu JavaScript netipizat care nu are metode supraîncărcate. de exemplu, dacă metoda dvs. supraîncărcat este numit de JavaScript, atunci se poate obține expediate doar cu o implementare metodă.

Există câteva discuții \ eo relevante pe CodePlex. de exemplu

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

Eu încă mai cred că ar trebui să genereze typescript toate if'ing și de comutare, astfel că nu ar trebui să o facă.

Javascript nu are nici un concept de supraîncărcare. Typescript nu este c # sau Java.

Dar puteți pune în aplicare supraîncărcarea dactilografiat.

Citește acest post http://www.gyanparkash.in/function-overloading-in-typescript/

De ce să nu folosească proprietatea opțională de interfață definită ca argument funcția ..

Pentru cazul în această întrebare, folosind o interfață de linie definită cu unele proprietăți opționale numai ar putea face în mod direct un cod ca ceva mai jos:

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

Deoarece suprasolicitării furnizate dactilografiat este, după cum se menționează în comentariile altora, doar o listă cu semnături diferite funcții fără sprijin de coduri de punere în aplicare corespunzătoare, cum ar fi alte limbi statice. Deci, punerea în aplicare încă mai trebuie să fie făcut într-un singur corp funcție, ceea ce face ca utilizarea funcției supraîncărcare dactilografiat nu la fel de confortabil ca astfel de limbi care susțin caracteristica supraîncărcării reală.

Cu toate acestea, există încă multe umpluturi noi si convenabile oferite dactilografiat care nu este disponibil în limbajul de programare moștenire, în cazul în care suportul de proprietate opțional într-o interfață anonimă este o astfel de abordare pentru a satisface zona confortabilă de suprasolicitării funcția moștenire, cred.

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

}

Cred că acest lucru ar trebui să funcționeze