Puis-je spécifier le type de paramètre parmi plusieurs types au lieu de tout type dans TypeScript?

Dans une déclaration de méthode en caractères d'imprimerie, le paramètre peut être de type tableau de chaînes de caractères, booléens, ou des chiffres. Dois-je le déclarer comme n'importe quel[] ou est-il un moyen de limiter le type d'entrée que sur l'un de ces trois types?

source d'informationauteur Amr

  1. 31

    Tapuscrit 1.4 introduit Types D'Union donc la réponse est maintenant oui, vous pouvez.

    function myFunc(param: string[] | boolean[] | number[]): void;

    À l'aide d'un autre type que celles indiquées va déclencher une erreur de compilation.

    Si vous voulez un tableau de plusieurs types spécifiques, vous pouvez utiliser les Types d'Union pour que ainsi:

    function myFunc(param: (string|boolean|number)[]): void;

    Notez que ceci est différent de ce que l'OP a demandé. Ces deux exemples ont des significations différentes.

  2. 7

    Cela semble un peu vieille question, mais de toute façon, je suis tombé sur elle, et a manqué cette autre réponse que j'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"
    }
}

    C'est à cause de la nouvelle Tapuscrit concept de "l'union-types".

    Vous pouvez voir plus de ici.

  3. 1

    Vous pouvez utiliser la fonction de surcharges pour ce 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
  4. 1

    Pas. La machine prend en charge une seule option TypeAnnotation dans un paramètre, par exemple x: stringou de toute, de sorte que vous ne pouvez pas l'état d'un ensemble de types autorisés.

    Cependant, la Machine prend en charge la fonction de surcharges (documentation p51):

    Fonction des surcharges de permettre une meilleure spécification des modes 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 typeof type de contrôles, mais cette compteurs du type ascpect de TypeScript un peu.

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

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

  6. 0

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

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