Marius

20080625 Array.indexOf(value)

Simple jQuery solution:
jQuery.inArray(value, Array)

The `Array.prototype.indexOf` method is now part of the ECMAScript 5th Edition Standard (published on Dec 2009), and finally, it has been correctly implemented on IE9 (which still in its Preview stage).

About your implementation, there are some flaws that I would like to address.

Checking:

if(!Array.indexOf){
//..
}

And later assigning the `Array.prototype.indexOf` property is not right, they two are different methods!

`Array.indexOf` is part of the “Array Generics” methods, introduced on the Mozilla Implementations only! (Rhino and SpiderMonkey, in JavaScript(TM) 1.7), and it is not part of the ECMAScript standard.

`Array.indexOf` does *not* exist on other ECMA-compliant implementations, for example in Safari, Chrome, WebKit and even in IE9, while they do implement the standard native `Array.prototype.indexOf` method.

This means that in those implementations the native method will be replaced with your code!, and that’s pretty bad, native methods are extremely fast and should be respected (check for `Array.prototype.indexOf`!).

In the ECMAScript 5th Edition Standard the method is completely described ( http://j.mp/cqP6r7 ), it needs to handle a second argument, a “fromIndex” to start the search looking forward from it (which can also be negative, in that case it will be taken as the offset from the end of the array).

Also, the method should compare the elements of the array using the Strict Equality operator, `===`. Comparing with the equals operator `==` will give you different results, for example:

['0'].indexOf(0); // Should return `-1`

But your implementation will return `0`, because the `===` operator does not make any type conversion (`’0′ == 0` produces true but `’0′ === 0` evaluates to false).

Aside of that, the method is described in the specification as “generic”, that means that it can be used on “array-like” objects, (an object that has a `length` property, and its value should be within the range of a 32-bit unsigned integer (from 0 to 2^32-1) and that contains numeric properties), e.g.:

var arrayLike = {0:’foo’, length:1};
Array.prototype.indexOf.call(arrayLike, ‘foo’); // 0

Your method is capable to handle the above example, but imagine what would happen if `length` were an arbitrary value like `Infinity` for example…

The algorithm described in the specification also checks the value of the `length` property ensuring that it is a Uint32…

There are even more aspects that a standards compliant implementation should check, but this comment is getting quite long :-)

A complete standards compliant method can be found on the Mozilla Developer Center: http://j.mp/aQtCpG

Thanks!