Funzione dattiloscritto che prende uno o una serie di oggetti

Question

Stiamo usando una semplice dichiarazione di funzione piuttosto dove la funzione accetta sia un singolo oggetto o una matrice di oggetti di un certo tipo.

semplice dichiarazione è:

interface ISomeInterface { 
    name: string; 
} 

class SomeClass { 
    public names: ISomeInterface[] = []; 

    public addNames(names: ISomeInterface | ISomeInterface[]): void { 
     names = (!Array.isArray(names)) ? [names] : names; 
     this.names = this.names.concat(names); 
    }  
} 

Ma dattiloscritto getta "tipo non è cedibile" errore.

C'è un modo migliore per farlo? Ovviamente potremmo avere due funzioni separate, ma penso che gestire single vs multiple in questo modo sia abbastanza buono.

Answer 1

È possibile rendere più facile

addNames(names: ISomeInterface | ISomeInterface[]): void { 
     this.names = this.names.concat(names); 
} 

Da MDN

The concat() method returns a new array comprised of the array on which it is called joined with the array(s) and/or value(s) provided as arguments.

Answer 2

Il modo dattiloscritto ufficiale gestisce questo è con firme multiple funzioni, ad esempio:

addNames(names: ISomeInterface): void; 
addNames(names: ISomeInterface[]): void; 
addNames(names: any): void { 
    ... 
} 

È possibile visualizzare ulteriori informazioni nel official handbook here

Answer 3

Si potrebbe anche utilizzare il parametro resto:

interface ISomeInterface { 
    name: string; 
} 

class SomeClass { 
    public names: ISomeInterface[] = []; // create an instance if applicable. 

    addNames(...names: ISomeInterface[]): void { 
     // the names argument will always be an array 
     this.names = this.names.concat(names); 
    } 
} 

Puoi chiamare come:

addNames(name1); // just pass one 
addNames(name1, name2, name3); // pass more comma separated 
addNames(...[name1, name2, name3]); // pass an array. 

Si noti che ho rimosso la parola chiave function, perché in caso contrario la parola chiave this all'interno del blocco del corpo potrebbe perdere l'ambito a seconda di chi la sta chiamando.

Answer 4

penso che questo è ciò che si vuole

interface ISomeInterface { 
    name: string; 
} 

class SomeClass { 
    public names: ISomeInterface[]; 

    addNames(names: ISomeInterface | ISomeInterface[]): void { 
     names = (names instanceof Array) ? names : [names]; 
     this.names = this.names.concat(<ISomeInterface[]>names) 
    }  
} 

Si desidera utilizzare instanceOf, non IsArray.