È possibile specificare il tipo di parametro come uno dei molti tipi anziché di qualsiasi tipo in TypeScript?

Question

In una dichiarazione di metodo in TypeScript, il parametro potrebbe essere di tipo array di stringhe, booleani o numeri. Devo dichiararlo come qualsiasi [] o c'è un modo per limitare il tipo di input come su questi tre tipi?

Answer 1

tipografico 1.4 introdotto Union Types quindi la risposta ora è sì, è possibile.

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

L'utilizzo di un altro tipo rispetto a quelli specificati genera un errore in fase di compilazione.

---

Se si desidera una serie di molteplici tipi specifici, è possibile utilizzare i tipi unione anche a questo:

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

Si noti che questo è diverso da quello che ha chiesto OP per. Questi due esempi hanno significati diversi.

Answer 2

È possibile utilizzare la funzione Sovraccarichi per fare questo:

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 

Answer 3

Dal stringhe, booleani e numeri sono tipi primitivi non credo ci sia un modo semplice. Se si usasse un set di diversi tipi di oggetti, si potrebbe magari trovare una super classe e quindi specificare quella super classe nell'interfaccia del proprio metodo. D'altra parte, è possibile utilizzare l'overloading dei metodi per specificare diverse implementazioni per array di stringhe, booleani e interi.

Answer 4

No. TypeScript supporta solo un singolo TypeAnnotation opzionale in un parametro, ad es. x: string, numero o qualsiasi, quindi non è possibile indicare un insieme di tipi consentiti.

Tuttavia, dattiloscritto supporta sovraccarichi di funzioni (documentazione P51):

sovraccarichi funzione permettono una specificazione più accurata dei modelli di invocazione supportati da una funzione di quanto sia possibile 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 è possibile utilizzare typeof controlli di tipo, ma questo contatori del tipo ascpect di Tipo script un po '.

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

Answer 5

Un altro modo per risolvere questo è quello di trovare i metodi e le proprietà comuni tra i tipi di input e dichiarare un tipo in linea nella dichiarazione metodo che contiene questi methos e proprietà comune. Ti piace questa:

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

Answer 6

Questo sembra un po 'vecchia questione, ma in ogni caso, mi sono imbattuto, e perdere questa altra risposta che porto.

Da dattiloscritto 1.4 sembra che sia possibile dichiarare più tipi possibili per un parametro funzione come questa:

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

Questo perché del nuovo concetto dattiloscritto di "unione-tipi".

Puoi vedere di più here.