Puis-je préciser le type de paramètre comme un des nombreux types de lieu tout type dactylographiée?

Cela semble un peu vieille question, mais de toute façon, je suis tombé, et a raté cette autre réponse que je vous apporte.

De tapuscrit 1.4 semble qu'il est possible de déclarer plusieurs types possibles pour un paramètre de fonction comme ceci:

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

En effet, du nouveau concept de tapuscrit de « union-types ».

Vous pouvez voir plus ici .

Non tapuscrit ne supporte qu'un seul TypeAnnotation en option dans un paramètre, par exemple x: string, le numéro ou tout, de sorte que vous ne pouvez pas dire un ensemble de types autorisés.

Cependant, tapuscrit prend en charge la fonction (surcharge documentation P51):

permettent de fonction surcharges une spécification plus précise des motifs d'invocation pris en charge par une fonction que ce qui est possible avec une seule signature. [...]

    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 vous pouvez utiliser des typeofcontrôles de type, mais les compteurs du type ascpect de type script un peu.

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

Vous pouvez utiliser la fonction pour les surcharges faire:

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

Une autre façon de résoudre est de trouver les méthodes communes et propriétés entre les types d'entrée et de déclarer un type en ligne dans la déclaration de méthode qui tient ces methos communes et propriétés. Comme ça:

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

Depuis les chaînes, les booléens et les chiffres sont les types primitifs, je ne pense pas qu'il y ait un moyen simple. Si vous utilisez un ensemble de différents types d'objets, vous pourriez peut-être venir avec une super classe et puis spécifiez que super-classe dans l'interface de votre méthode. D'autre part, vous pouvez également utiliser la surcharge de méthode pour définir les différentes implémentations pour les tableaux de chaînes, booléens et entiers.