¿Puedo especificar Tipo de parámetro como uno de muchos tipos En lugar de cualquier tipo a máquina de escribir?

Esto parece un poco vieja pregunta, pero de todos modos, me encontré con él, y se perdió esta otra respuesta que les traigo.

De mecanografiado 1.4 parece que es posible declarar múltiples tipos posibles para un parámetro función como esta:

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

Esto es debido al nuevo concepto de "unión mecanografiado-tipos".

Puede ver más aquí .

No. mecanografiado sólo admite un único TypeAnnotation opcional en un parámetro, por ejemplo x: string, número o cualquier, lo que no puede indicar un conjunto de tipos permitidos.

Sin embargo, mecanografiado soporta sobrecargas de función (p51) documentación:

sobrecargas de función permiten una especificación más precisa de los patrones de invocación con el apoyo de una función que es posible con una sola firma. [...]

    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 puede utilizar typeoflos controles de tipo, pero esto contradice la ascpect tipo de tipo de secuencias de comandos un poco.

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

Puede utilizar las sobrecargas de función para hacer esto:

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

Otra forma de resolver esto es encontrar los métodos y propiedades comunes entre los tipos de entrada y declarar un tipo de línea en la declaración del método que mantiene estos methos y propiedades comunes. Me gusta esto:

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

Como las cadenas, booleanos y los números son tipos primitivos no creo que hay una manera sencilla. Si desea utilizar un conjunto de diferentes tipos de objetos, tal vez podría llegar a una superclase y luego especificar que superclase en el interfaz de su método. Por otro lado, también se puede utilizar para especificar la sobrecarga de métodos diferentes implementaciones de matrices de cadenas, booleanos y enteros.