Check variable equality against a list of values

Question

I'm checking a variable, say foo, for equality to a number of values. For example,

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

The point is that it is rather much code for such a trivial task. I came up with the following:

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

but also this does not completely appeal to me, because I have to give redundant values to the items in the object.

Does anyone know a decent way of doing an equality check against multiple values?

Answer 1

In ECMA2016 you can use the includes method. It's the cleanest way I've seen. (Supported by all major browsers)

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

Answer 2

You could use an array and indexOf:

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

Answer 3

Using the answers provided, I ended up with the following:

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

It can be called like:

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

---

Edit: I came across this 'trick' lately which is useful if the values are strings and do not contain special characters. For special characters is becomes ugly due to escaping and is also more error-prone due to that.

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

To be more precise, this will check the exact string, but then again is more complicated for a simple equality test:

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

Answer 4

Now you may have a better solution to resolve this scenario, but other way which i preferred.

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    
}

I preferred above solution over the indexOf check where you need to check index as well.

includes docs

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

Answer 5

This is easily extendable and readable:

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

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

But not necessarily easier :)

Answer 6

You can write if(foo in L(10,20,30)) if you define L to be

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

    return obj;
};

Answer 7

var a = [1,2,3];

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

Note that indexOf is not in the core ECMAScript. You'll need to have a snippet for IE and possibly other browsers that dont support 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;
  };
}

Answer 8

Also, since the values against which you're checking the result are all unique you can use the Set.prototype.has() as well.

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

Answer 9

For a larger list of values that you compare with often, it is likely more optimal to first construct a Set and use Set#has for a constant time check rather than Array#includes which runs in linear time.

const values = new Set([1, 2, 12]);
if(values.has(foo)){
   // do something
}

Answer 10

I liked the accepted answer, but thought it would be neat to enable it to take arrays as well, so I expanded it to this:

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

You can remove type coercion by changing == to ===.

Answer 11

If you have access to Underscore, you can use the following:

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

contains used to work in Lodash as well (prior to V4), now you have to use includes

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

Answer 12

I simply used jQuery inArray function and an array of values to accomplish this:

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

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

if(test >= 0) // true

Answer 13

This is a little helper arrow function:

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

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

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

More info here...

Answer 14

It really comes down the the use case. For example, if you only care if the variable is of any specific value, using Array.some() would be the best bet as it basically performs a forEach on any iterable type and returns true at the first value the condition meets. This makes it one of the fastest ways to find out if any option meets the condition and this is an example of how it's used.

const anyOfThese = [1, 2, 14];
const doesHave0 = 0;
const doesHave1 = 1;
const doesHave14 = 14;

// checks all
const found0 = anyOfThese.some(singleValue => singleValue === doesHave0));
console.log("found0", found0);
// -> false

// check anyOfThese[0] = (1) returns without checking the rest
const found1 = anyOfThese.some(singleValue => singleValue === doesHave1));
console.log("found1", found1);
// -> true

// checks anyOfThese[0...14] until it finds singleValue === 14
const found14 = anyOfThese.some(singleValue => singleValue === doesHave14));
console.log("found14", found14);
// -> true

However, if you're storing values in some set that you want to track the total result of and you're only adding items if the set doesn't already have them for example. Using an actual Set would be better because Sets can only have one entry for each unique value and simply adding it to the set like such.

const mSet = new Set();
mSet.add(2);
mSet.add(5);
mSet.add(2);
console.debug("mSet", mSet); // -> mSet Set {2, 5}

and if you need to know wether or not the value was added you can simply compare the size of the Set inline with the add like this

const mSet = new Set();
mSet.add(2);
const addedFive = mSet.size < mSet.add(5).size;
console.debug("addedFive", addedFive);  // -> true
const addedTwo = mSet.size < mSet.add(2).size;
console.debug("addedTwo", addedTwo);  // -> false
console.debug("mSet", mSet); // -> Set {2, 5}

And that < can be any logical check, so you could say

const mSet = new Set([2]);
mSet.size === mSet.add(2); // -> returns true; didn't add 2
mSet.size !== mSet.add(2); // -> returns false; didn't add 2
mSet.size === mSet.add(5); // -> returns false; added 5
mSet.size !== mSet.add(6); // -> returns true; added 6

Or you could also use any function, so you could also say

const mSet = new Set([2]);
mSet.size === mSet.remove(2); // -> returns false; removed 2
mSet.size === mSet.remove(2); // -> returns true; didn't remove anything

The < and > operators make it easier to clarify what you're checking for but === and !== provide a broader range of possibilities in cases where the exact change may not be important, but rather if anything did or did not change.

Just remember when writing your logic that these checks mutate your values, so that Set will really have the checked value added or removed.

Answer 15

Using the ES6 syntax you can do:

Object.prototype.in = function (...args) {
  return args.includes(this.valueOf());
}

which incidentally also checks for deep equality. The valueOf() method is needed as this is an object.

Answer 16

For posterity you might want to use regular expressions as an alternative. Pretty good browser support as well (ref. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match#Browser_compatibility)

Try this

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