C'è un modo per fare il sovraccarico di metodo in dittivetti?

Question

C'è un modo per fare il sovraccarico del metodo in linguaggio dattilografo?

Voglio ottenere qualcosa del genere:

class TestClass {
    someMethod(stringParameter: string): void {
        alert("Variant #1: stringParameter = " + stringParameter);
    }

    someMethod(numberParameter: number, stringParameter: string): void {
        alert("Variant #2: numberParameter = " + numberParameter + ", stringParameter = " + stringParameter);
    }
}

var testClass = new TestClass();
testClass.someMethod("string for v#1");
testClass.someMethod(12345, "string for v#2");

.

Ecco un esempio di ciò che non voglio fare (odio davvero quella parte del sovraccarico di Hack in JS):

class TestClass {
    private someMethod_Overload_string(stringParameter: string): void {
        // A lot of code could be here... I don't want to mix it with switch or if statement in general function
        alert("Variant #1: stringParameter = " + stringParameter);
    }

    private someMethod_Overload_number_string(numberParameter: number, stringParameter: string): void {
        alert("Variant #2: numberParameter = " + numberParameter + ", stringParameter = " + stringParameter);
    }

    private someMethod_Overload_string_number(stringParameter: string, numberParameter: number): void {
        alert("Variant #3: stringParameter = " + stringParameter + ", numberParameter = " + numberParameter);
    }

    public someMethod(stringParameter: string): void;
    public someMethod(numberParameter: number, stringParameter: string): void;
    public someMethod(stringParameter: string, numberParameter: number): void;

    public someMethod(): void {
        switch (arguments.length) {
        case 1:
            if(typeof arguments[0] == "string") {
                this.someMethod_Overload_string(arguments[0]);
                return;
            }
            return; // Unreachable area for this case, unnecessary return statement
        case 2:
            if ((typeof arguments[0] == "number") &&
                (typeof arguments[1] == "string")) {
                this.someMethod_Overload_number_string(arguments[0], arguments[1]);
            }
            else if ((typeof arguments[0] == "string") &&
                     (typeof arguments[1] == "number")) {
                this.someMethod_Overload_string_number(arguments[0], arguments[1]);
            }
            return; // Unreachable area for this case, unnecessary return statement
        }
    }
}


var testClass = new TestClass();
testClass.someMethod("string for v#1");
testClass.someMethod(12345, "string for v#2");
testClass.someMethod("string for v#3", 54321);

.

Answer 1

Secondo le specifiche, il dattilografia supporta il sovraccarico del metodo di supporto, ma è abbastanza imbarazzante e include un sacco di lavoro manuale controllando i tipi di parametri.Penso che sia principalmente perché il più vicino possibile che sia possibile ottenere il sovraccarico del metodo in JavaScript semplice include che anche il controllo e il dattiloscritto tenta di non modificare gli organismi del metodo effettivi per evitare qualsiasi costo di performance di runtime non necessario.

Se lo capisco correttamente, devi prima scrivere una dichiarazione del metodo per ciascuno dei sovraccarichi e quindi one Implementazione del metodo che controlla i suoi argomenti per decidere quale sovraccarico è stato chiamato.La firma dell'attuazione deve essere compatibile con tutti i sovraccarichi.

class TestClass {
    someMethod(stringParameter: string): void;
    someMethod(numberParameter: number, stringParameter: string): void;

    someMethod(stringOrNumberParameter: any, stringParameter?: string): void {
        if (stringOrNumberParameter && typeof stringOrNumberParameter == "number")
            alert("Variant #2: numberParameter = " + stringOrNumberParameter + ", stringParameter = " + stringParameter);
        else
            alert("Variant #1: stringParameter = " + stringOrNumberParameter);
    }
}

.

Answer 2

Aggiornamento per chiarezza. Il sovraccarico del metodo in dattiloscritto è una funzione utile nella misura in cui consente di creare definizioni di tipo per le librerie esistenti con un'API che deve essere rappresentata.

Quando si scrive il tuo codice, tuttavia, potresti essere in grado di evitare il sovraccarico cognitivo di sovraccarichi utilizzando parametri opzionali o predefiniti. Questa è l'alternativa più leggibile ai sovraccarichi del metodo e mantiene anche la tua API onesta come avrai evitato di creare sovraccarichi con ordinamento non intuitivo.

La legge generale dei sovraccarichi dattiloscritti è:

.

Se puoi Elimina le firme di sovraccarico e tutti i tuoi test passano, non è necessario sovraccarichi dattiloscritti

Di solito è possibile ottenere la stessa cosa con parametri opzionali o predefiniti o con tipi di unione o con un po 'di orientamento agli oggetti.

La domanda attuale

La domanda reale richiede un sovraccarico di:

someMethod(stringParameter: string): void {

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

.

Ora anche nelle lingue che supportano i sovraccarichi con implementazioni separate (Nota: i sovraccarichi di tipo dattiloscritti condividono una singola implementazione) - I programmatori sono consigli per fornire la coerenza nell'ordinare. Questo farebbe le firme:

someMethod(stringParameter: string): void {

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

.

Il stringParameter è sempre richiesto, quindi va prima. Potresti scrivere questo come un sovraccarico di dattiloscritto funzionante:

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 seguendo la legge dei sovraccarichi dattiloscritti, siamo in grado di eliminare le firme di sovraccarico e tutti i nostri test passeranno ancora.

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

.

La domanda attuale, nell'ordine effettivo

Se sei stato determinato 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 è un sacco di ramificazione per allenarsi dove mettere i parametri, ma volevi davvero conservare questo ordine se stai leggendo così lontano ... ma aspetta, cosa succede se applichiamo la legge dei sovraccarichi di tipo dattiloscritti? < / P >.

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

.

Abbastanza ramificatura già

Naturalmente, data la quantità di controllo del tipo che dobbiamo fare ... forse la risposta migliore è semplicemente avere due metodi:

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

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

.

Answer 3

desidero.Voglio anche questa caratteristica, ma il dattiloscritto deve essere interoperabile con JavaScript non adipendente che non ha metodi sovraccaricati.I.e. Se il tuo metodo sovraccarico è chiamato da JavaScript, quindi può essere inviata solo in un'implementazione del metodo.

Ci sono alcune discussioni rilevanti su Codeplex.per esempio.

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

Penso ancora che i tuoi dattiloscritti dovrebbero generare tutto il punto e commutazione in modo che non avremmo bisogno di farlo.

Answer 4

Perché non usare Interfaccia definita proprietà opzionale come L'argomento della funzione ..

Per quanto riguarda questa domanda, utilizzando un'interfaccia in linea definita con alcune proprietà opzionali solo potrebbe fare direttamente il codice 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é il sovraccarico fornito nel dattiloscritto è, come menzionato nei commenti degli altri, solo un elenco delle diverse firme della funzione senza supportare i corrispondenti codici di implementazione come altre lingue statiche. Quindi l'implementazione deve ancora essere eseguita in un solo corpo funzione, il che rende l'utilizzo del sovraccarico di funzionalità di tipo dattiloscritto non confortevole come tali lingue a supporto della funzione di sovraccarico reale.

Tuttavia, ci sono ancora numerosi e comodi cose forniti nel dattiloscritto che non è disponibile nel linguaggio di programmazione legacy, dove il supporto della proprietà opzionale in un'interfaccia anonima è un tale approccio per soddisfare la zona confortevole dal sovraccarico della funzione legacy, penso .

Answer 5

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

Ma puoi implementare il sovraccarico in dittivetti.

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