Vérifier l'égalité des variables par rapport à une liste de valeurs

Je vérifie une variable, disons foo, pour l'égalité à un certain nombre de valeurs. Par exemple,

if( foo == 1 || foo == 3 || foo == 12 ) {
    // ...
}

Le fait est qu'il s'agit plutôt de code pour une tâche aussi triviale. J'ai trouvé ce qui suit:

if( foo in {1: 1, 3: 1, 12: 1} ) {
    // ...
}

mais aussi cela ne me plaît pas complètement, car je dois donner des valeurs redondantes aux éléments de l'objet.

Quelqu'un connaît-il une manière décente de faire un test d'égalité par rapport à plusieurs valeurs?

Vous pouvez utiliser un tableau et indexOf:

if ([1,3,12].indexOf(foo) > -1)

Dans ECMA2016, vous pouvez utiliser la méthode includes . C'est la manière la plus propre que j'ai vue. (Pris en charge par tous les principaux navigateurs, sauf IE (Polyfill est dans le lien)

if([1,3,12].includes(foo)) {
    // ...
}

En utilisant les réponses fournies, je me suis retrouvé avec ce qui suit:

Object.prototype.in = function() {
    for(var i=0; i<arguments.length; i++)
       if(arguments[i] == this) return true;
    return false;
}

Il peut être appelé comme:

if(foo.in(1, 3, 12)) {
    // ...
}

Edit: Je suis tombé sur cette «astuce» récemment qui est utile si les valeurs sont des chaînes et ne contiennent pas de caractères spéciaux. Pour les caractères spéciaux, cela devient moche en raison de l'échappement et est également plus sujet aux erreurs à cause de cela.

/foo|bar|something/.test(str);

Pour être plus précis, cela vérifiera la chaîne exacte, mais là encore, c'est plus compliqué pour un simple test d'égalité:

/^(foo|bar|something)$/.test(str);

Vous pouvez écrire if(foo in L(10,20,30))si vous définissez Lêtre

var L = function()
{
    var obj = {};
    for(var i=0; i<arguments.length; i++)
        obj[arguments[i]] = null;

    return obj;
};

Ceci est facilement extensible et lisible:

switch (foo) {
    case 1:
    case 3:
    case 12:
        // ...
        break

    case 4:
    case 5:
    case 6:
        // something else
        break
}

Mais pas forcément plus facile :)

var a = [1,2,3];

if ( a.indexOf( 1 ) !== -1 ) { }

Notez que indexOf n'est pas dans le noyau ECMAScript. Vous aurez besoin d'un extrait pour IE et éventuellement d'autres navigateurs qui ne prennent pas en charge Array.prototype.indexOf.

if (!Array.prototype.indexOf)
{
  Array.prototype.indexOf = function(searchElement /*, fromIndex */)
  {
    "use strict";

    if (this === void 0 || this === null)
      throw new TypeError();

    var t = Object(this);
    var len = t.length >>> 0;
    if (len === 0)
      return -1;

    var n = 0;
    if (arguments.length > 0)
    {
      n = Number(arguments[1]);
      if (n !== n)
        n = 0;
      else if (n !== 0 && n !== (1 / 0) && n !== -(1 / 0))
        n = (n > 0 || -1) * Math.floor(Math.abs(n));
    }

    if (n >= len)
      return -1;

    var k = n >= 0
          ? n
          : Math.max(len - Math.abs(n), 0);

    for (; k < len; k++)
    {
      if (k in t && t[k] === searchElement)
        return k;
    }
    return -1;
  };
}

De plus, puisque les valeurs par rapport auxquelles vous vérifiez le résultat sont toutes uniques, vous pouvez également utiliser Set.prototype.has () .

var valid = [1, 3, 12];
var goodFoo = 3;
var badFoo = 55;

// Test
console.log( new Set(valid).has(goodFoo) );
console.log( new Set(valid).has(badFoo) );

Maintenant, vous pouvez avoir une meilleure solution pour résoudre ce scénario, mais d'une autre manière que j'ai préférée.

const arr = [1,3,12]
if( arr.includes(foo)) { // it will return true if you `foo` is one of array values else false
  // code here    
}

J'ai préféré la solution ci-dessus à la vérification d'indexOf où vous devez également vérifier l'index.

comprend des documents

if ( arr.indexOf( foo ) !== -1 ) { }

J'ai aimé la réponse acceptée, mais j'ai pensé que ce serait bien de lui permettre de prendre également des tableaux, alors je l'ai étendue à ceci:

Object.prototype.isin = function() {
    for(var i = arguments.length; i--;) {
        var a = arguments[i];
        if(a.constructor === Array) {
            for(var j = a.length; j--;)
                if(a[j] == this) return true;
        }
        else if(a == this) return true;
    }
    return false;
}

var lucky = 7,
    more = [7, 11, 42];
lucky.isin(2, 3, 5, 8, more) //true

Vous pouvez supprimer la contrainte de type en changeant ==à ===.

Si vous avez accès à Underscore, vous pouvez utiliser les éléments suivants:

if (_.contains([1, 3, 12], foo)) {
  // ...
}

contains autrefois fonctionnait dans Lodash (avant la V4), vous devez maintenant utiliser includes

if (_.includes([1, 3, 12], foo)) {
  handleYellowFruit();
}

Ceci est une petite fonction d'aide arror:

const letters = ['A', 'B', 'C', 'D'];

function checkInList(arr, val) {
  return arr.some(arrVal => val === arrVal);
}

checkInList(letters, 'E');   // false
checkInList(letters, 'A');   // true

Plus d'infos ici...

J'ai simplement utilisé la fonction jQuery inArray et un tableau de valeurs pour accomplir cela:

myArr = ["A", "B", "C", "C-"];

var test = $.inArray("C", myArr)  
// returns index of 2 returns -1 if not in array

if(test >= 0) // true

Pour la postérité, vous voudrez peut-être utiliser des expressions régulières comme alternative. Très bon support de navigateur également (réf. Https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match#Browser_compatibility )

Essaye ça

if (foo.toString().match(/^(1|3|12)$/)) {
    document.write('Regex me IN<br>');
} else {
    document.write('Regex me OUT<br>');
}