Kann ich statt einer beliebigen, in Typoskript Parameter Typ als eine von vielen Arten angeben?

Dies scheint ein wenig alte Frage, aber wie auch immer, ich kam über ihn, und verpasste diese andere Antwort, die ich bringen.

Von Typoskript 1.4 scheint, dass es möglich ist, mehrere mögliche Typen für einen Funktionsparameter wie folgt zu erklären:

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

Dies ist wegen des neuen Typoskript Konzepts des „union-Typs“.

Sie können mehr sehen hier .

Nr Typoskript unterstützt nur eine einzige optionale TypeAnnotation in einem Parameter, zum Beispiel x: string, die Anzahl oder überhaupt, so dass Sie nicht einen Satz von zulässigen Typen angeben können.

Allerdings unterstützt Typoskript Funktion Überlastungen (Dokumentation p51):

Funktion Überlastungen erlauben eine genauere Spezifizierung der Muster der Aufruf durch eine Funktion unterstützt als mit einer einzigen 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 Sie verwenden können , typeofTypprüfungen, aber die Art ascpect Zähler Typ Script ein wenig.

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

Sie können Funktions Überlastungen, dies zu tun:

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

Ein anderer Weg, dies zu lösen, ist die gängigen Methoden und Eigenschaften zwischen den Eingangsarten zu finden und eine Inline-Typ in der Methodendeklaration erklären, dass diese gemeinsamen methos und Eigenschaften besitzt. So was:

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

Da Strings, Boolesche Werte und Zahlen primitive Typen sind glaube ich nicht, dass es eine einfache Art und Weise ist. Wenn Sie eine Reihe von verschiedenen Objekttypen verwenden würden, könnte man vielleicht mit einer Super-Klasse kommt und dann angeben, dass Superklasse in der Schnittstelle Ihrer Methode. Auf der anderen Seite können Sie auch Methodenüberladung verwenden, um verschiedene Implementierungen für Arrays von Strings, Boolesche Werte und Zahlen angeben.