JavaScript equivalent of PHPs in_array()

JavaScript equivalent of PHPs in_array()

No, it doesnt have one. For this reason most popular libraries come with one in their utility packages. Check out jQuerys inArray and Prototypes Array.indexOf for examples.

jQuerys implementation of it is as simple as you might expect:

function inArray(needle, haystack) {
    var length = haystack.length;
    for(var i = 0; i < length; i++) {
        if(haystack[i] == needle) return true;
    }
    return false;
}

If you are dealing with a sane amount of array elements the above will do the trick nicely.

EDIT: Whoops. I didnt even notice you wanted to see if an array was inside another. According to the PHP documentation this is the expected behavior of PHPs in_array:

$a = array(array(p, h), array(p, r), o);

if (in_array(array(p, h), $a)) {
    echo ph was foundn;
}

if (in_array(array(f, i), $a)) {
    echo fi was foundn;
}

if (in_array(o, $a)) {
    echo o was foundn;
}

// Output:
//  ph was found
//  o was found

The code posted by Chris and Alex does not follow this behavior. Alexs is the official version of Prototypes indexOf, and Chriss is more like PHPs array_intersect. This does what you want:

function arrayCompare(a1, a2) {
    if (a1.length != a2.length) return false;
    var length = a2.length;
    for (var i = 0; i < length; i++) {
        if (a1[i] !== a2[i]) return false;
    }
    return true;
}

function inArray(needle, haystack) {
    var length = haystack.length;
    for(var i = 0; i < length; i++) {
        if(typeof haystack[i] == object) {
            if(arrayCompare(haystack[i], needle)) return true;
        } else {
            if(haystack[i] == needle) return true;
        }
    }
    return false;
}

And this my test of the above on it:

var a = [[p,h],[p,r],o];
if(inArray([p,h], a)) {
    alert(ph was found);
}
if(inArray([f,i], a)) {
    alert(fi was found);
}
if(inArray(o, a)) {
    alert(o was found);
}  
// Results:
//   alerts ph was found
//   alerts o was found

Note that I intentionally did not extend the Array prototype as it is generally a bad idea to do so.

There is now Array.prototype.includes:

The includes() method determines whether an array includes a certain
element, returning true or false as appropriate.

var a = [1, 2, 3];
a.includes(2); // true 
a.includes(4); // false

Syntax

arr.includes(searchElement)
arr.includes(searchElement, fromIndex)

JavaScript equivalent of PHPs in_array()

Array.indexOf was introduced in JavaScript 1.6, but it is not supported in older browsers. Thankfully the chaps over at Mozilla have done all the hard work for you, and provided you with this for compatibility:

if (!Array.prototype.indexOf)
{
  Array.prototype.indexOf = function(elt /*, from*/)
  {
    var len = this.length >>> 0;

    var from = Number(arguments[1]) || 0;
    from = (from < 0)
         ? Math.ceil(from)
         : Math.floor(from);
    if (from < 0)
      from += len;

    for (; from < len; from++)
    {
      if (from in this &&
          this[from] === elt)
        return from;
    }
    return -1;
  };
}

There are even some handy usage snippets for your scripting pleasure.

Related Posts

Leave a Reply

Your email address will not be published.