Aggiornamento per chiarezza. Metodo sovraccarico a macchina è una caratteristica utile in quanto permette di creare definizioni del tipo per le biblioteche esistenti con un'API che ha bisogno di essere rappresentati.

Quando si scrive il proprio codice, però, si può ben essere in grado di evitare il sovraccarico cognitivo dei sovraccarichi che utilizzano parametri opzionali o di default. Questo è il più leggibile alternativa al metodo sovraccarichi e mantiene anche la vostra API onesto come si evitano la creazione di sovraccarichi con ordine poco intuitivo.

La legge generale della dattiloscritto sovraccarica è:

Se è possibile eliminare le firme di sovraccarico e di tutti i test passano, non è necessario sovraccarichi dattiloscritto

Di solito è possibile ottenere la stessa cosa con i parametri facoltativi, o di default - o con i tipi di unione, o con un po 'di orientamento agli oggetti.

La questione reale

La domanda attuale richiede un sovraccarico di:

someMethod(stringParameter: string): void {

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

Ora anche nelle lingue che sostengono sovraccarichi con implementazioni distinte (nota: sovraccarichi dattiloscritto condividono una singola implementazione) - programmatori sono consigli per fornire coerenza nella ordinazione. Questo renderebbe le firme:

someMethod(stringParameter: string): void {

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

Il stringParameterè sempre necessario, così si va per primo. Si potrebbe scrivere questo come un sovraccarico di lavoro dattiloscritto:

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

Ma dopo la legge di sovraccarichi dattiloscritto, siamo in grado di eliminare le firme di sovraccarico e di tutti i nostri test sarà ancora passare.

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

La questione reale, nell'ordine effettivo

Se si erano decisi a persistere con l'ordine originale, i sovraccarichi sarebbero:

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

Ora che è un sacco di ramificazione per capire dove mettere i parametri, ma si ha realmente voluto conservare questo ordine se state leggendo questo lontano ... ma aspetta, cosa succede se applichiamo la legge di sovraccarichi dattiloscritto?

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

Basta Branching Già

Naturalmente, data la quantità di controllo di tipo abbiamo bisogno di fare ... forse la risposta migliore è semplicemente quello di avere due metodi:

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

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

Spero. Voglio che questa caratteristica troppo ma dattiloscritto deve essere interoperabile con JavaScript senza tipo che non ha metodi di overload. cioè se il vostro metodo di overload viene chiamato da JavaScript, allora si può ottenere spedito solo a un'implementazione del metodo.

Ci \ Sa alcune discussioni importanti su CodePlex. per esempio

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

Penso ancora che dattiloscritto dovrebbe generare tutto l'if'ing e commutazione in modo che non avrebbe bisogno di farlo.

Javascript non ha alcun concetto di sovraccarico. Dattiloscritto non è C # o Java.

Ma è possibile implementare un sovraccarico a macchina.

Leggi questo post http://www.gyanparkash.in/function-overloading-in-typescript/

Perché non utilizzare l'interfaccia definita proprietà facoltativa come l'argomento della funzione ..

Per il caso in questione, utilizzando un'interfaccia in linea definita con alcune proprietà opzionali solo potrebbe rendere il codice direttamente come qualcosa di seguito:

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

Poiché sovraccarichi fornito a macchina è, come detto in commenti degli altri, solo un elenco di firme diverse della funzione senza sostenere codici di attuazione corrispondenti come altri linguaggi statici. Così l'attuazione devono ancora essere fatto in un solo corpo della funzione, il che rende l'uso della funzione di sovraccarico a macchina non confortevoli come tali linguaggi che supportano la funzione di sovraccarico reale.

Tuttavia, c'è ancora molte materie nuove e convenienti fornite a macchina che non è disponibile nel linguaggio di programmazione legacy, in cui il sostegno proprietà facoltativa in un'interfaccia anonimo è un tale approccio per soddisfare la zona confortevole dalla funzione legacy sovraccarico, credo.

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

}

Penso che questo dovrebbe funzionare