Determinar se a string está na lista em JavaScript

No SQL, podemos ver se uma string está em uma lista como esta:

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

Qual é uma boa maneira de fazer isso em JavaScript? É tão desajeitado fazer isso:

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

E não tenho certeza sobre o desempenho ou a clareza disso:

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

Ou pode-se usar a função switch:

var str = 'a',
   flag = false;

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

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

Mas isso é uma bagunça horrível. Alguma ideia?

Nesse caso, tenho que usar o Internet Explorer 7 para uma página da intranet corporativa. Portanto ['a', 'b', 'c'].indexOf(str) !== -1, não funcionará nativamente sem um pouco de açúcar de sintaxe.

Você pode ligar para indexOf:

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

EcmaScript 6

Se você estiver usando o ES6, poderá criar uma matriz dos itens e usar includes:

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

Isto tem algumas vantagens inerentes sobre indexOfporque ele pode corretamente testar a presença de NaNna lista, e pode igualar faltando elementos da matriz, tais como o do meio em [1, , 2]que undefined. includestambém funciona em matrizes digitadas em JavaScript , como Uint8Array.

Se você estiver preocupado com o suporte ao navegador (como o IE ou o Edge), verifique Array.includesem CanIUse.Com e, se desejar direcionar um navegador ou uma versão do navegador que está faltando includes, recomendo o polyfill.io para o polyfilling.

Sem uma matriz

Você pode adicionar uma nova isInListpropriedade às seqüências de caracteres da seguinte maneira:

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;
   }
}

Em seguida, use-o assim:

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

Você pode fazer a mesma coisa por Number.prototype.

Array.indexOf

Se você estiver usando um navegador moderno, indexOfsempre funciona. No entanto, para o IE8 e versões anteriores, você precisará de um polyfill.

Se indexOfretornar -1, o item não estará na lista. Lembre-se, porém, de que esse método não será verificado corretamente NaNe, embora possa corresponder a um explícito undefined, não pode corresponder a um elemento ausente undefinedcomo na matriz [1, , 2].

Polyfill para indexOfou includesno IE, ou qualquer outro suporte ao navegador / versão falta

Se você não quiser usar um serviço como o polyfill.io, como mencionado acima, sempre poderá incluir nos seus próprios polyfills personalizados compatíveis com os padrões do código-fonte. Por exemplo, a Mozilla Developer Network tem uma para indexOf.

Nessa situação em que tive que criar uma solução para o Internet Explorer 7, "rolei minha própria" versão mais simples da indexOf()função que não é compatível com os padrões:

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

No entanto, não acho que modificar Array.prototypeseja a melhor resposta a longo prazo. Modificações Objecte Arrayprotótipos em JavaScript podem levar a erros graves. Você precisa decidir se isso é seguro em seu próprio ambiente. É importante notar que a iteração de uma matriz (quando Array.prototype adicionou propriedades) for ... inretornará o novo nome da função como uma das chaves:

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!

Seu código pode funcionar agora, mas no momento em que alguém no futuro adicionar uma biblioteca ou plug-in JavaScript de terceiros que não esteja protegendo zelosamente contra chaves herdadas, tudo poderá ser interrompido.

A maneira antiga de evitar essa quebra é, durante a enumeração, verificar cada valor para ver se o objeto realmente o possui como uma propriedade não herdada if (arr.hasOwnProperty(x))e somente então trabalhar com isso x.

A nova forma ES6 para evitar este problema chave extra-é usar of, em vez de in, for (let x of arr). No entanto, a menos que você possa garantir que todas as suas bibliotecas de código e de terceiros sigam estritamente esse método, para os fins desta pergunta você provavelmente desejará usar includescomo indicado acima.

A maioria das respostas sugere o Array.prototype.indexOfmétodo, o único problema é que ele não funcionará em nenhuma versão do IE anterior ao IE9.

Como alternativa, deixo mais duas opções que funcionarão em todos os navegadores:

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


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

As matrizes têm um indexOfmétodo que pode ser usado para procurar por strings:

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

Um truque que eu usei é

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

Você poderia fazer algo como

>>> 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

Aqui está o meu:

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');

Este é mais rápido se você estiver bem ao passar uma matriz:

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

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

Aqui está o jsperf: http://jsperf.com/bmcgin-inlsit

RegExpé universal, mas eu entendo que você está trabalhando com matrizes. Então, confira essa abordagem. Eu uso, e é muito eficaz e rápido!

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

rx.test(str);

Você também pode aplicar algumas modificações, ou seja:

One-liner

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

Não diferencia maiúsculas de minúsculas

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

E muitos outros!

Usando indexOf (não funciona com o IE8).

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

Para dar suporte ao IE8, você pode implementar o indexOf do Mozilla.

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

Expressões regulares via String.prototype.match (docs).

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

}

Parece que você precisa usar a função in_array.

jQuery -> inArray

Protótipo -> Array.indexOf

Ou, veja estes exemplos se você não estiver usando jQuery ou 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 estilística: as variáveis ​​denominadas thisthing thatthing, devem ser nomeadas para informar algo sobre o que elas contêm (substantivo).

Além de indexOf(que outros pôsteres sugeriram), o uso do Enumerable.include () do protótipo pode torná-lo mais limpo e conciso:

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

Obrigado pela pergunta e pela solução usando o método Array.indexOf.

Eu usei o código dessa solução para criar uma função inList () que, IMO, tornaria a escrita mais simples e a leitura mais clara:

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
}

Estou surpreso que ninguém tenha mencionado uma função simples que usa uma string e uma lista.

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));

Minha solução resulta em uma sintaxe como esta:

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

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

E eu implemento isso estendendo o protótipo básico de Objeto, assim:

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

Como alternativa, podemos nomear o método isInArray (mas provavelmente não o inArray) ou simplesmente isIn.

Vantagens: Simples, direto e auto-documentado.

Uma versão simplificada da resposta do SLaks também funciona:

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

.... desde strings são uma espécie de matrizes próprias. :)

Se necessário, implemente a função indexof para o Internet Explorer, conforme descrito antes de mim.