Determina se la stringa è presente nell'elenco in JavaScript

In SQL possiamo vedere se una stringa è in un elenco in questo modo:

Column IN ('a', 'b', 'c')

Qual è un buon modo per farlo in JavaScript? È così goffo fare questo:

if (expression1 || expression2 || str === 'a' || str === 'b' || str === 'c') {
   // do something
}

E non sono sicuro delle prestazioni o della chiarezza di questo:

if (expression1 || expression2 || {a:1, b:1, c:1}[str]) {
   // do something
}

Oppure si potrebbe usare la funzione switch:

var str = 'a',
   flag = false;

switch (str) {
   case 'a':
   case 'b':
   case 'c':
      flag = true;
   default:
}

if (expression1 || expression2 || flag) {
   // do something
}

Ma è un casino orribile. Qualche idea?

In questo caso, devo usare Internet Explorer 7 per una pagina Intranet aziendale. Quindi ['a', 'b', 'c'].indexOf(str) !== -1non funzionerà in modo nativo senza zucchero di sintassi.

Puoi chiamare indexOf:

if (['a', 'b', 'c'].indexOf(str) >= 0) {
    //do something
}

EcmaScript 6

Se stai usando ES6, puoi costruire un array di elementi e usare includes:

['a', 'b', 'c'].includes('b')

Ciò ha alcuni vantaggi intrinseci indexOfperché può testare correttamente la presenza di NaNnell'elenco e può abbinare elementi di array mancanti come quello centrale [1, , 2]a undefined. includesfunziona anche su matrici tipizzate JavaScript come Uint8Array.

Se sei preoccupato per il supporto del browser (come per IE o Edge), puoi controllare Array.includessu CanIUse.Com e se desideri scegliere come target un browser o una versione del browser mancante includes, ti consiglio polyfill.io per il polyfilling.

Senza matrice

È possibile aggiungere una nuova isInListproprietà alle stringhe come segue:

if (!String.prototype.isInList) {
   String.prototype.isInList = function() {
      let value = this.valueOf();
      for (let i = 0, l = arguments.length; i < l; i += 1) {
         if (arguments[i] === value) return true;
      }
      return false;
   }
}

Quindi usalo così:

'fox'.isInList('weasel', 'fox', 'stoat') // true
'fox'.isInList('weasel', 'stoat') // false

Puoi fare la stessa cosa per Number.prototype.

Array.indexOf

Se stai utilizzando un browser moderno, indexOffunziona sempre. Tuttavia, per IE8 e versioni precedenti è necessario un polyfill.

Se indexOfrestituisce -1, l'elemento non è nell'elenco. Tuttavia, tieni presente che questo metodo non controlla correttamente NaNe, sebbene possa corrispondere a un esplicito undefined, non può corrispondere a un elemento mancante undefinedcome nell'array [1, , 2].

Polyfill per indexOfo includesin IE o qualsiasi altro browser / versione privo di supporto

Se non si desidera utilizzare un servizio come polyfill.io come menzionato sopra, è sempre possibile includere i propri polyfill personalizzati conformi agli standard del codice sorgente. Ad esempio, Mozilla Developer Network ne ha uno per indexOf.

In questa situazione in cui dovevo creare una soluzione per Internet Explorer 7, ho "lanciato la mia" versione più semplice della indexOf()funzione che non è conforme agli standard:

if (!Array.prototype.indexOf) {
   Array.prototype.indexOf = function(item) {
      var i = this.length;
      while (i--) {
         if (this[i] === item) return i;
      }
      return -1;
   }
}

Tuttavia, non penso che la modifica Array.prototypesia la migliore risposta a lungo termine. La modifica Objecte i Arrayprototipi in JavaScript possono portare a gravi bug. Devi decidere se farlo è sicuro nel tuo ambiente. La nota principale è che iterando un array (quando Array.prototype ha aggiunto proprietà) for ... inrestituirà il nuovo nome della funzione come uno dei tasti:

Array.prototype.blah = function() { console.log('blah'); };
let arr = [1, 2, 3];
for (let x in arr) { console.log(x); }
// Result:
0
1
2
blah // Extra member iterated over!

Il tuo codice potrebbe funzionare ora, ma nel momento in cui qualcuno in futuro aggiungerà una libreria o plugin JavaScript di terze parti che non protegge con zelo dalle chiavi ereditate, tutto può rompersi.

Il vecchio modo per evitare tale rottura è, durante l'enumerazione, verificare ogni valore per vedere se l'oggetto ha effettivamente come proprietà non ereditata if (arr.hasOwnProperty(x))e solo allora lavorare con quello x.

Il nuovo modo ES6 per evitare questo problema extra-chiave è di usare ofal posto di in, for (let x of arr). Tuttavia, a meno che tu non possa garantire che tutto il tuo codice e le librerie di terze parti si attengano rigorosamente a questo metodo, quindi ai fini di questa domanda probabilmente vorrai semplicemente usare includescome sopra indicato.

La maggior parte delle risposte suggerisce il Array.prototype.indexOfmetodo, l'unico problema è che non funzionerà su nessuna versione di IE prima di IE9.

In alternativa, ti lascio altre due opzioni che funzioneranno su tutti i browser:

if (/Foo|Bar|Baz/.test(str)) {
  // ...
}


if (str.match("Foo|Bar|Baz")) {
  // ...
}

Le matrici hanno un indexOfmetodo che può essere usato per cercare stringhe:

js> a = ['foo', 'bar', 'baz']
foo,bar,baz
js> a.indexOf('bar')
1
js> a.indexOf('quux')
-1

Un trucco che ho usato è

>>> ("something" in {"a string":"", "somthing":"", "another string":""})
false
>>> ("something" in {"a string":"", "something":"", "another string":""})
true

Potresti fare qualcosa del genere

>>> a = ["a string", "something", "another string"];
>>> b = {};
>>> for(var i=0; i<a.length;i++){b[a[i]]="";} /* Transform the array in a dict */
>>> ("something" in b)
true

Ecco il mio:

String.prototype.inList=function(list){
    return (Array.apply(null, arguments).indexOf(this.toString()) != -1)
}

var x = 'abc';
if (x.inList('aaa','bbb','abc'))
    console.log('yes');
else
    console.log('no');

Questo è più veloce se stai bene passando un array:

String.prototype.inList=function(list){
    return (list.indexOf(this.toString()) != -1)
}

var x = 'abc';
if (x.inList(['aaa','bbb','abc']))
    console.log('yes')

Ecco il jsperf: http://jsperf.com/bmcgin-inlsit

RegExpè universale, ma capisco che stai lavorando con le matrici. Quindi, controlla questo approccio. Lo uso per usarlo, è molto efficace e velocissimo!

var str = 'some string with a';
var list = ['a', 'b', 'c'];
var rx = new RegExp(list.join('|'));

rx.test(str);

Puoi anche applicare alcune modifiche, ad esempio:

One-liner

new RegExp(list.join('|')).test(str);

Insensibile alle maiuscole

var rx = new RegExp(list.join('|').concat('/i'));

E molti altri!

Utilizzando indexOf (non funziona con IE8).

if (['apple', 'cherry', 'orange', 'banana'].indexOf(value) >= 0) {
    // found
}

Per supportare IE8, è possibile implementare l'indiceOf di Mozilla.

if (!Array.prototype.indexOf) {
    // indexOf polyfill code here
}

Espressioni regolari tramite String.prototype.match (docs).

if (fruit.match(/^(banana|lemon|mango|pineapple)$/)) {

}

Sembra che tu debba usare la funzione in_array.

jQuery -> inArray

Prototype -> Array.indexOf

Oppure, vedi questi esempi se non stai usando jQuery o Prototype:

• http://phpjs.org/functions/in_array:432
• http://www.bitrepository.com/equivalent-of-phps-in_array-function.html
• http://codingforums.com/showthread.php?t=63796

Nota stilistica: le variabili denominate thisthing thatthing, dovrebbero essere nominate per dirti qualcosa su ciò che contengono (sostantivo).

Oltre a indexOf(che altri poster hanno suggerito), l'uso del prototipo Enumerable.include () può rendere questo più pulito e conciso:

var list = ['a', 'b', 'c'];
if (list.include(str)) {
  // do stuff
}

Grazie per la domanda e la soluzione che utilizza il metodo Array.indexOf.

Ho usato il codice di questa soluzione per creare una funzione inList () che, IMO, avrebbe reso la scrittura più semplice e la lettura più chiara:

function inList(psString, psList) 
{
    var laList = psList.split(',');

    var i = laList.length;
    while (i--) {
        if (laList[i] === psString) return true;
    }
    return false;
}

USO:

if (inList('Houston', 'LA,New York,Houston') {
  // THEN do something when your string is in the list
}

Sono sorpreso che nessuno abbia menzionato una semplice funzione che accetta una stringa e un elenco.

function in_list(needle, hay)
{
    var i, len;

    for (i = 0, len = hay.length; i < len; i++)
    {
        if (hay[i] == needle) { return true; }
    }

    return false;
}

var alist = ["test"];

console.log(in_list("test", alist));

La mia soluzione si traduce in una sintassi come questa:

// Checking to see if var 'column' is in array ['a', 'b', 'c']

if (column.isAmong(['a', 'b', 'c']) {
  // Do something
}

E lo implemento estendendo il prototipo di oggetto di base, in questo modo:

Object.prototype.isAmong = function (MyArray){
   for (var a=0; a<MyArray.length; a++) {
      if (this === MyArray[a]) { 
          return true;
      }
   }
   return false;
}

In alternativa, potremmo nominare il metodo isInArray (ma probabilmente non inArray) o semplicemente isIn.

Vantaggi: semplice, diretto e auto-documentante.

Una versione semplificata della risposta di SLaks funziona anche:

if ('abcdefghij'.indexOf(str) >= 0) {
    // Do something
}

.... poiché le stringhe sono una sorta di array stessi. :)

Se necessario, implementare la funzione indexof per Internet Explorer come descritto prima di me.