Mogę określić parametr typu jako jednym z wielu rodzajów Zamiast dowolnego typu na maszynie?

To wydaje się trochę stare pytanie, ale tak czy owak, natknąłem się na niego, a brakowało tej innej odpowiedzi, że przyniesie.

Od maszynopis 1.4 Wydaje się, że możliwe jest, aby zadeklarować kilka możliwych rodzajów dla parametru funkcji takich jak to:

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

To właśnie z powodu nowej koncepcji maszynopis „Unii typów”.

Można zobaczyć więcej tutaj .

Nie maszynopis obsługuje tylko jeden opcjonalny TypeAnnotation pomocą parametru, np x: string, numeru lub w ogóle, więc nie można stwierdzić, zestaw dozwolonych typów.

Jednak maszynopis obsługuje przeciążeń funkcyjnych (dokumentacja P51):

przeciążenia funkcyjne pozwalają na dokładniejsze określenie wzorców wywołania obsługiwanego przez funkcję niż jest to możliwe za pomocą jednego podpisu. [...]

    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 można użyć typeofkontrole typu, ale ten przeciwdziała ascpect typu dla typów Script trochę.

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

Można użyć funkcji przeciążeń, aby to zrobić:

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

Innym sposobem rozwiązania tego problemu jest znalezienie wspólnych metod i właściwości między typami wejściowych i zadeklarować typu in-line w deklaracji metody, która posiada te wspólne Methos i właściwości. Lubię to:

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

Ponieważ ciągi, wartości logiczne i numery są prymitywne typy nie sądzę, jest to prosty sposób. Jeśli chcesz użyć zestawu różnych typów obiektów, mógłbyś może pochodzić z super klasy, a następnie określić, że super klasy w interfejsie swojej metody. Z drugiej strony, można również użyć metody przeciążania określić różne implementacje dla tablic ciągów logicznych i liczb.