Déterminer si la chaîne est dans la liste en JavaScript

En SQL, nous pouvons voir si une chaîne est dans une liste comme ceci:

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

Quelle est la bonne façon de procéder en JavaScript? C'est tellement maladroit de faire ça:

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

Et je ne suis pas sûr de la performance ou de la clarté de ceci:

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

Ou on pourrait utiliser la fonction de commutation:

var str = 'a',
   flag = false;

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

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

Mais c'est un désordre horrible. Des idées?

Dans ce cas, je dois utiliser Internet Explorer 7 car c'est pour une page intranet d'entreprise. Donc ['a', 'b', 'c'].indexOf(str) !== -1, ne fonctionnera pas nativement sans sucre syntaxique.

Vous pouvez appeler indexOf:

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

EcmaScript 6

Si vous utilisez ES6, vous pouvez construire un tableau des éléments et utiliser includes:

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

Cela a des avantages inhérents plus indexOfcar il peut bien tester la présence de NaNla liste, et peut correspondre à des éléments de tableau manquants tels que celui du milieu dans [1, , 2]la undefined. includesfonctionne également sur des tableaux de type JavaScript tels que Uint8Array.

Si vous êtes préoccupé par la prise en charge du navigateur (comme pour IE ou Edge), vous pouvez vérifier Array.includessur CanIUse.Com , et si vous souhaitez cibler un navigateur ou une version de navigateur manquante includes, je recommande polyfill.io pour le polyfilling.

Sans tableau

Vous pouvez ajouter une nouvelle isInListpropriété aux chaînes comme suit:

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

Ensuite, utilisez-le comme ceci:

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

Vous pouvez faire la même chose pour Number.prototype.

Array.indexOf

Si vous utilisez un navigateur moderne, cela indexOffonctionne toujours. Cependant, pour IE8 et versions antérieures, vous aurez besoin d'un polyfill.

Si indexOfrenvoie -1, l'élément n'est pas dans la liste. Gardez cependant à l'esprit que cette méthode ne vérifiera pas correctement NaNet qu'elle peut correspondre à un undefinedélément explicite , elle ne peut pas correspondre à un élément manquant undefinedcomme dans le tableau [1, , 2].

Polyfill pour indexOfou includesdans IE, ou tout autre navigateur / version sans support

Si vous ne souhaitez pas utiliser un service comme polyfill.io comme mentionné ci-dessus, vous pouvez toujours inclure dans vos propres polyfills personnalisés conformes aux normes du code source. Par exemple, Mozilla Developer Network en a un pour indexOf.

Dans cette situation où j'ai dû faire une solution pour Internet Explorer 7, j'ai "roulé ma propre" version plus simple de la indexOf()fonction qui n'est pas conforme aux normes:

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

Cependant, je ne pense pas que la modification Array.prototypesoit la meilleure réponse à long terme. La modification Objectet les Arrayprototypes en JavaScript peuvent entraîner de graves bugs. Vous devez décider si cela est sûr dans votre propre environnement. Il est important de noter que l'itération d'un tableau (lorsque Array.prototype a ajouté des propriétés) avec for ... inrenverra le nouveau nom de la fonction comme l'une des clés:

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!

Votre code peut fonctionner maintenant, mais au moment où quelqu'un dans le futur ajoutera une bibliothèque ou un plugin JavaScript tiers qui ne protège pas avec zèle contre les clés héritées, tout peut casser.

L'ancienne façon d'éviter cette rupture est, pendant l'énumération, de vérifier chaque valeur pour voir si l'objet l'a réellement en tant que propriété non héritée avec if (arr.hasOwnProperty(x))et seulement ensuite de travailler avec x.

La nouvelle façon de ES6 pour éviter ce problème extra-clé est d'utiliser au oflieu de in, for (let x of arr). Cependant, à moins que vous ne puissiez garantir que tout votre code et vos bibliothèques tierces respectent strictement cette méthode, alors aux fins de cette question, vous voudrez probablement simplement utiliser includescomme indiqué ci-dessus.

La plupart des réponses suggèrent la Array.prototype.indexOfméthode, le seul problème est qu'elle ne fonctionnera sur aucune version d'IE avant IE9.

Comme alternative, je vous laisse deux autres options qui fonctionneront sur tous les navigateurs:

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


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

Les tableaux ont une indexOfméthode qui peut être utilisée pour rechercher des chaînes:

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

Un truc que j'ai utilisé est

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

Vous pourriez faire quelque chose comme

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

Voici la mienne:

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

Celui-ci est plus rapide si vous êtes d'accord pour passer un tableau:

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

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

Voici le jsperf: http://jsperf.com/bmcgin-inlsit

RegExpest universel, mais je comprends que vous travaillez avec des tableaux. Alors, découvrez cette approche. Je l'utilise pour l'utiliser, et c'est très efficace et très rapide!

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

rx.test(str);

Vous pouvez également appliquer certaines modifications, à savoir:

Bon mot

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

Insensible à la casse

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

Et plein d'autres!

Utiliser indexOf (cela ne fonctionne pas avec IE8).

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

Pour prendre en charge IE8, vous pouvez implémenter l'indexOf de Mozilla.

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

Expressions régulières via String.prototype.match (docs).

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

}

On dirait que vous devez utiliser la fonction in_array.

jQuery -> inArray

Prototype -> Array.indexOf

Ou, voyez ces exemples si vous n'utilisez pas 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

Note stylistique: les variables nommées thisthing thatthing, devraient être nommées pour vous dire quelque chose sur ce qu'elles contiennent (nom).

En plus de indexOf(ce que d'autres affiches ont suggéré), l'utilisation de Enumerable.include () du prototype peut rendre cela plus net et concis:

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

Merci pour la question et la solution utilisant la méthode Array.indexOf.

J'ai utilisé le code de cette solution pour créer une fonction inList () qui, à l'OMI, rendrait l'écriture plus simple et la lecture plus claire:

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

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

USAGE:

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

Je suis surpris que personne n'ait mentionné une fonction simple qui prend une chaîne et une liste.

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

Ma solution se traduit par une syntaxe comme celle-ci:

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

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

Et je l'implémente en étendant le prototype d'objet de base, comme ceci:

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

Nous pourrions également nommer la méthode isInArray (mais probablement pas inArray) ou simplement isIn.

Avantages: Simple, direct et auto-documenté.

Une version simplifiée de la réponse de SLaks fonctionne également:

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

.... puisque les chaînes sont en quelque sorte des tableaux eux-mêmes. :)

Si nécessaire, implémentez la fonction indexof pour Internet Explorer comme décrit précédemment.