Are JavaScript Arrays actually implemented as arrays?

The difference between a JavaScript Array, and Object is not very big. In fact it seems Array mainly adds the length field, so you can use both Arrays and Objects as numeric arrays:

var ar = new Array();
ar[0] = "foo";
ar["bar"] = "foo";

var ob = new Object();
ob[0] = "foo";
ob["bar"] = "foo";

assert(ar[0] == ob[0] == ar["0"] == ob["0"] == ar.bar == ob.bar); // Should be true.

So my questions is, in popular JavaScript engines (V8, JavaScriptCore, SpiderMonkey, etc.), how is this handled? Obviously we do not want our arrays to be actually stored as hash maps with key values! How can we be reasonably sure our data is stored as an actual array?

As far as I can see there are a few approaches engines could take:

1. Array is implemented exactly the same way as Object – as an associative array with string keys.
2. Array is a special case, with a std::vector-like array backing the numeric keys, and some density heuristic to prevent insane memory use if you do ar[100000000] = 0;
3. Array is the same as Object, and all objects get a heuristic to see if using an array would make more sense.
4. Something insanely complicated that I haven’t thought of.

Really this would be simpler if there were a proper array type (cough WebGL typed arrays cough).

Answer

In SpiderMonkey, arrays are implemented basically as C arrays of jsvals. These are referred to as “dense arrays”. However, if you start doing un-array-like things to them — like treating them like objects — their implementation is changed to something which very much resembles objects.

Moral of the story: when you want an array, use an array. When you want an object, use an object.

Oh, a jsval is a sort of variadic type which can represent any possible JavaScript value in a 64 bit C type.