indexOf with multiple arguments

Question

Is it possible to use multiple arguments when determining indexOf on an array?

I want to determine if my array contains any of three integers. Important to note at this stage that the array will only have one value (if it has more, it won't reach this code block).

array.indexOf(123 || 124 || 125) === 0

So if array = [123] then my indexOf should be 0 and therefore true.

If array = [124] then my indexOf should be 0 and therefore true.

What I am finding is happening is [123] works OK but it's not even bothering to check the indexOf for the 2nd or 3rd arguments, and is just returning false.

http://codepen.io/anon/pen/WxmyGp?editors=0011

Fortunetelling

It wouldn't make much sense at all for indexOf to accept multiple arguments, e.g. indexOf(1, 2, 3), because in the general case, what should the result be if multiple elements exist in the array…? – Ernieernst

If you're open to using lodash, check out the answer here: https://mcmap.net/q/2037108/-lodash-_-hasintersection – Von

Answer 1

The || operator returns the left hand side if it is true, otherwise it returns the right hand side. 123 || 124 || 125 just means 123.

If you want to test if any of multiple values are in an array, then you have to test each one in turn.

array.indexOf(123) == 0 || array.indexOf(124) == 0 || array.indexOf(125) == 0 

Since you only care about one specific index the array, you can turn the whole thing on its head:

[123, 124, 125].indexOf(array[0]) > -1

Confucius

@dave Both have O(m * n) complexity. Your approach just has m expressions joined by ||s. Quentin's implementation appears to run considerably faster than yours in Chrome: plnkr.co/edit/yz9VRRJ3D0pIMqbSunJJ?p=preview – Enneastyle

@Enneastyle obviously those results speak for themselves, but I am having a hard time understanding why. I posted a related question to ask why that approach is faster. – Effulgence

Answer 2

You can do this using Array.some().

The nice thing about this approach is that you will only have to iterate through the array once. If you || multiple indexOf() calls together, you're going to keep iterating the array with every missed search.

function checkArray(array) {
  return array.some(function(item) {
    return item == 123 || item == 124 || item == 125;
  });
};

console.log(checkArray([123, 456, 789]));
console.log(checkArray([456, 789]));
console.log(checkArray([789, 456, 125]));

Effulgence

If I read the Q correctly, the solution would be a simple array == [123] || array == [124] || array == [125]. – Iiette

@Iiette — No. == tests if both sides are the same object. Different arrays won't match even if they are identical. – Confucius

Answer 3

If you want to get multiple results one other way of doing this is Array.prototype.filter(). Bu this will return you the objects itself. If you are interested in the indices then you have to combine it with Array.prototype.reduce() such as;

var a = [1,2,3],
    b = a.filter(e => e === 1 || e === 2)
         .reduce((p,c) => p.concat(a.indexOf(c)),[]);
console.log(b);

Timothytimour