Aktualizace pro přehlednost. Metoda přetížení na stroji je užitečná vlastnost, pokud to umožňuje vytvořit definice typu pro existující knihovny s API, které musí být zastoupeny.

Při psaní vlastního kódu, i když, můžete také být schopen vyhnout kognitivní režii přetížení pomocí volitelného nebo výchozí parametry. To je čitelnější alternativou k metodě přetížení a také udržuje váš API upřímný, jak budete vyhnout vytváření přetížení s unintuitive objednání.

Obecný zákon strojopisem přetížení je:

Pokud můžete smazat podpisy přetížení a všechny vaše testy projít, nemusíte strojopisem přetížení

Obvykle můžete dosáhnout totéž s volitelným nebo výchozích parametrů - nebo s typy unií nebo s trochou objektové orientace.

Skutečná otázka

Skutečná otázka se ptá na přetížení:

someMethod(stringParameter: string): void {

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

Nyní dokonce v jazycích, které podporují přetížení se samostatnými implementacemi (Poznámka: strojopisem přetížení sdílet jediné implementaci) - programátoři jsou rady S cílem zajistit soulad v objednávce. To by podpisy:

someMethod(stringParameter: string): void {

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

stringParameterJe vždy potřeba, tak to jde jako první. Dalo by se napsat to jako pracovní přetížení strojopisem:

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

Ale po právu strojopisu přetížení, můžeme odstranit podpisy přetížení a všechny naše testy ještě projít.

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

Skutečná otázka, v samotném Řádu

Pokud jste byli odhodláni vytrvat s původním pořadí, přičemž přetížení bude vypadat následovně:

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

Nyní, když je hodně větvení vymyslet, kam umístit parametry, ale opravdu chtěl zachovat tuto objednávku, pokud čtete tento daleko ... ale počkat, co se stane, pokud budeme uplatňovat zákon strojopisem přetížení?

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

Dost větvení Již

Samozřejmě, že vzhledem k množství typové kontroly musíme udělat ... možná nejlepší odpovědí je prostě mít dvě metody:

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

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

Přeji si. Chci tuto funkci příliš, ale na psacím stroji musí být interoperabilní se bez definovaného typu JavaScript, která nemá přetížené metody. tj Je-li přetížení metoda volána z JavaScriptu pak to může jen získat odeslány do jedné implementaci metody.

Tam \ sa málo relevantní diskusi o CodePlex. např

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

Pořád si myslím, strojopisem by měly vytvářet všechny if'ing a přepínací takže by nebylo nutné to udělat.

Javascript nemá žádnou představu o přetížení. Strojopisem není c # nebo Java.

Ale můžete implementovat přetížení na psacím stroji.

Přečtěte si tento příspěvek http://www.gyanparkash.in/function-overloading-in-typescript/

Proč nepoužívat fakultativní majetku definované rozhraní jako argument funkce ..

Pro případ v této otázce, s použitím vložené rozhraní definované s některými volitelnými vlastnostmi jen mohl přímo, aby kód, jako něco níže:

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

Vzhledem k tomu, přetížení uvedené v strojopis, jak je uvedeno v komentáři druhých, jen seznam funkcí v různých podpisů bez podložky příslušného prováděcího kódy jako ostatní statické jazyky. Takže implementace ještě musí být provedeno pouze v jednom těle funkce, která umožňuje využití funkce přetížení na stroji není tak pohodlné jako takové jazyky, které podporují reálnou funkci přetížení.

Nicméně stále existuje mnoho nových a pohodlné výrobky uvedené na stroji, který není k dispozici ve starších programovacího jazyka, kde volitelná podpora nemovitost v anonymním rozhraní je takový přístup ke splnění komfortní zónu ze starší funkce přetížení, myslím.

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

}

Myslím, že by to mělo fungovat