Pot specifica Parametru Tip ca una dintre mai multe tipuri în loc de orice tip dactilografiat?

Acest lucru pare un pic vechi întrebare, dar oricum, am dat peste ea, și a ratat acest alt răspuns pe care le aduc.

Din typescript 1.4 se pare că este posibil să se declare mai multe tipuri posibile pentru un parametru funcție de genul:

class UtilsClass {
    selectDom(element: string | HTMLElement):Array<HTMLElement> {
        //Here will come the "magic-logic"
    }
}

Acest lucru se datorează faptului că a noului concept de „typescript-tipuri de unire“.

Puteti vedea mai multe aici .

Nu . Typescript suportă un singur TypeAnnotation opțional într - un parametru, de exemplu x: string, numărul sau orice, astfel încât să nu se poate afirma un set de tipuri de permise.

Cu toate acestea, typescript suportă suprasarcini funcție (documentația p51):

suprasarcini funcționale permit o specificare mai exactă a modelelor de invocare susținută de o funcție decât este posibil cu o singură semnătură. [...]

    function attr(name: string): string;
    function attr(name: string, value: string): Accessor;
    function attr(map: any): Accessor;
    function attr(nameOrMap: any, value: string): any {
        if (nameOrMap && typeof nameOrMap === "object") {
            // handle map case
        }
        else {
            // handle string case
        }
    }

Otherwsie puteți utiliza typeofcontroalele de tip, dar acest lucru contracareaza ascpect tip de tip Script un pic.

function myFunc(x){
    if(typeof x !== "string" && typeof x !== "object" && typeof x !== "number")
        throw new TypeError("Unsupported type!");
}

Puteți utiliza funcția suprasarcini pentru a face acest lucru:

class Thing {
    public foo(x: number[]);
    public foo(x: bool[]);
    public foo(x: string[]);
    public foo(x: any[]) {
       // Note: You'll have to do type checking on 'x' manually
       // here if you want differing behavior based on type
    }
}

// Later...
var t = new Thing();
t.foo(someArray); // Note: External callers will not see the any[] signature

Un alt mod de a rezolva acest lucru este de a găsi comune metode și proprietăți între tipurile de intrare și declară un tip în linie în declarația metoda care deține aceste Methos și proprietăți comune. Asa:

methodName(param1: { prop1: number; prop2: string; }, param2: { propA: bool; propB: string; } ): methodResultType;

Din moment ce siruri de caractere, boolean și numere sunt tipuri primitive nu cred că există un mod simplu. Dacă s-ar folosi un set de diferite tipuri de obiecte, ai putea veni, poate, cu o clasă de super și apoi specificați acea clasă super-în interfața de metoda. Pe de altă parte, ai putea folosi, de asemenea, metoda de supraîncărcări pentru a specifica diferite implementari pentru matrici de siruri de caractere, boolean și numere întregi.