Javascript (beginner): Performance issue using arbitrary numerical properties?

When I do something like this:

var o = new Array();
o[20] 开发者_StackOverflow社区= true;
o[1000] = true;
o[4000] = true;

Is it reasonable to expect that only 3 elements will be allocated or can the implementation decide to suddenly allocate something with 4000 elements?

The reason I'm asking is that when I do this I see in firebug an indication that there are actually 4000 undefined in o. are they really there?

Now that we know that o is an Array, I can answer you precisely.

No, the elements will not be 'allocated' or 'created'.

When you make an assignment of an index property to an Array object, which is greater than the actual length of the array two things happen:

1. The index named property is created
2. The length property is incremented, to be the index + 1

For example:

var o = [];
o[4000] = true;

o.hasOwnProperty(0); // false, the property doesn't exist
o.hasOwnProperty(1); // false
o.hasOwnProperty(4000); // true, the property exist

As you can see, the hasOwnProperty method returns false when we test the presence of the 0 or 1 properties, because they don't exist physically on the object, whereas it returns true for 4000, the property that was created.

When Firebug detects that the object being printed in the console is an array-like object, it will simply make a loop, showing each of the index values from 0 to length - 1.

Firebug detects array-like objects simply by looking if they have a length property whose its value is an unsigned 32-bit integer (less than 2^32 - 1), and if they have a splice property that is a function, for example, the following object will be detected and printed as an Array on the Firebug's console:

console.log({length:3, splice:function(){}});
// Firebug will log: `[undefined, undefined, undefined]`

a) That code is not valid. You need either var o = {}; // object or var o = []; // array.

b) In the first case, the object is sparse. In the second, it may depend on the interpreter; in modern browsers it is also sparse. Try o[99999999] = "hi"; and see how much memory your browser does or does not allocate. If it does not go up by at least 10MB, your arrays are sparse.

I think this one answers the question.

Are Javascript arrays sparse?

And according to that one, arrays are spares, thats is, if you use for(item in array) you only get 3 items, not 4000 but if you use array.length it will take the larges integer value and return one larger, look here:

http://www.crockford.com/javascript/survey.html

Linkpad will use a for(item = 0; item < array.length; item++) and that one will return undefined for any index that is not present in the array.

/* On the other hand, if you have a very large index any array manipulation will have to loop through each index- it won't skip from one defined item to the the next defined item.

*/

var A= [];
A[0]= 'a';
A[10]= 'b';
A[4000000]= 'c';
alert(A.filter(function(itm){
    return itm!= undefined;
}));

Javascript will generate all elements inbetween, always. You may want to use o.length to verify the length of the array. It will return 4000 and not 3.