Kan jeg angi Parameter Type som en av mange typer i stedet for noen type i typescript?

Dette virker litt gamle spørsmålet, men likevel, jeg kom over det, og gikk glipp av denne andre svar som jeg bringe.

Fra Loggfila 1,4 synes at det er mulig å erklære flere mulige typer for en funksjon parameter som dette:

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

Dette er på grunn av den nye typescript begrepet "union-typer".

Du kan se mer her .

Nei. Loggfila støtter bare ett valgfritt TypeAnnotation i en parameter, for eksempel x: string, nummer eller noe, slik at du ikke kan oppgi et sett av tillatte typer.

Men støtter Loggfila funksjons overbelastning (dokumentasjon P51):

Funksjon overbelastning tillate en mer nøyaktig angivelse av mønstrene av påkalling understøttet av en funksjon enn det er mulig med en enkelt signatur. [...]

    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 du kan bruke typeoftypen kontroller, men dette motvirker den type ascpect av Type Script litt.

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

Du kan bruke funksjons overbelastning å gjøre dette:

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

En annen måte å løse dette på er å finne de vanlige metoder og egenskaper mellom inngangstypene og erklære en in-line-typen i fremgangsmåten erklæring som inneholder disse felles methos og egenskaper. Som dette:

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

Siden strenger, booleans og tall er primitive typer jeg tror ikke det er en enkel måte. Hvis du vil bruke et sett av ulike objekttyper, kan du kanskje komme opp med en super klasse og deretter angi at super klasse i grensesnittet på metoden. På den annen side, kan du også bruke metoden overbelastning angi ulike implementeringer for matriser av strenger, booleans og heltall.