Megadhatok Paramétertípus mint egy a sok típusai helyett bármilyen típusú géppel?

Úgy tűnik, ez egy kicsit régi kérdés, de mindegy, rábukkantam, és hiányzott a másik válasz, hogy hozok.

Tól géppel 1.4 tűnik, hogy lehetséges, hogy állapítsa meg, több lehetséges típusai a függvény paraméter, mint ez:

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

Ez azért van, mert az új géppel koncepció „unió-típus”.

Láthatjuk több itt .

Nem géppel támogat egyetlen választható TypeAnnotation egy paramétert, például x: string, szám vagy bármilyen, így nem lehet megállapítani egy sor engedélyezett típusokat.

Azonban typescript támogatja függvény túlterhelés (dokumentáció p51):

Funkció túlterhelés teszi pontosabb leírás a minták hívási támogatott a funkció, mint lehetséges egységes aláírás. [...]

    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 használhatja typeoftípusú ellenőrzés, de ez kompenzálja a típusú ascpect a Type Script egy kicsit.

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

Használhatja funkciót túlterhelés erre:

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

Egy másik módja, hogy megoldja ezt az, hogy megtaláljuk a közös módszerek és tulajdonságok közötti bemeneti típusok és állapítsa meg, in-line típusú eljárásban nyilatkozatot, hogy tartja ezeket a közös Methos és tulajdonságait. Mint ez:

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

Mivel húrok, logikai értékek és számok primitív típusok Nem hiszem, hogy van egy egyszerű módja. Ha használ egy sor különböző típusú objektumot, akkor talán felér egy szuper osztály, majd adja meg, hogy szuper osztály a felületen a módszer. Másrészt, akkor is használhatja az eljárás túlterhelést megadásához különböző megvalósítások tömbök húrok, logikai értékek és egészek.