Kan ik opgeven Parameter Type als een van de vele soorten In plaats van elk type met de schrijfmachine?

Dit lijkt een beetje oud vraag, maar hoe dan ook, kwam ik het, en miste deze andere antwoord dat ik breng.

Van Typescript 1.4 lijkt erop dat het mogelijk is om meerdere mogelijke verklaren voor een functie parameter als volgt uit:

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

Dit komt door de nieuwe typoscript concept van de "Union-types".

U kunt meer te zien hier .

Nee typoscript ondersteunt slechts één optionele TypeAnnotation in een parameter, bijvoorbeeld x: string, of enig, zodat u een set van toegestane types niet kan stellen.

Echter, Typescript ondersteunt functie overbelasting (documentatie P51):

Functie overbelasting maken een nauwkeuriger specificatie van de patronen van aanroeping ondersteund door een functie dan met één hand. [...]

    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 u kunt gebruiken typeofsoort controles, maar dit tellers het type ascpect van Type Script een beetje.

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

U kunt de functie overbelasting te gebruiken om dit te doen:

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

Een andere manier om dit op te lossen is om de gemeenschappelijke methoden en eigenschappen tussen de invoertypen vinden en verklaren een in-lijntype in de werkwijze verklaring dat deze gemeenschappelijke methos en eigenschappen bezit. Zoals dit:

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

Sinds strings, booleans en nummers zijn primitieve types Ik denk niet dat er een eenvoudige manier. Als je een set van verschillende types object zou gebruiken, zou je misschien komen met een super klasse en geef die super klasse in de interface van uw methode. Aan de andere kant, kun je ook gebruik maken van methode overbelasting om verschillende implementaties opgeven voor arrays van strings, booleans en gehele getallen.