Couple of questions tho…
Firstly, without new (as you state) you are giving up the prototype object. But I thought one very real benefit of the prototype object is to assign methods to them once and have them shared by all, thus saving space. It seems your recommended obj literal notation requires the repeated inclusion of inline functions for every object created. I presume you consider this an acceptable trade off?

http://java.pakcarid.com/default.aspx?sub=25&Sls=25

Secondly, how do you represent static variable/methods (public or private) without the use of new?


js> p = "Foo"
Foo
js> p.weight = 42
42
js> p.weight // Returns undefined
js> q = new String("Foo")
Foo
js> q.weight = 42
42
js> q.weight
42


The string value cannot have new properties. The same thing is valid for other types.

Now somebody please correct me if I’m wrong, but this seems useless, *except* as a shortcut for implementors to preallocate or resize the backing data store and retreive the size of the store without itterating all the elements. But they don’t seem to be using it that way. In the benchmark above, there should be a number of reallocation / resize oprtations for the inner loop with the literal constructor form. Even if the backing store is initialized to some default size > 0, and grows exponentially every time there is an attempt to insert past the end, there should at least be a few reallocate / resize ops for 500 insertions. And that would presumably have a speed impact (even if slight) over 10,000 iterations. But the timings don’t show any speed difference over the signal:noise threshold as compared with the constructor form using the new keyword with an initial length.

So if this dispairity between the actual number of non-inherited properties and the length property, and the constructor form with a default length, are not being utilized by implementors for optimization purposes–then what use are they? It seems like, without some kind of practical use, this is simply a chance for faux pas like this:

var arry = new Array (20);

// …stuff you thought initialized the array, but didn’t

for (var i = 0; i < arry.length; ++i) {
do_stuff (arry[i].foo); // throws
}

Also, slightly confusingly, mutating methods like push and pop *always* increment and decrement the length property, and operate on the index relative to the length propery (rather than the actual index of the last initialized element).

Wait, what? According to ECMA-262(3) § 15.4, every Array has an invariant property called “length” that is necessarily the number of non-inherited properties + 1, such that if a new property is added, “length” is increased, and if length is set to less number of non-inherited properties + 1, properties are deleted. And according to §15.4.2.2, the “new Array(len)” form initializes a new object and sets “length” to “len”.

One would think that implementors would take advantage of this to pre-allocate a list of size (object size*len) when the “new Array(len)” form is used. I haven’t profiled the memory paging or GC, but just on speed, a micro-benchmark testing the literal constructor versus the “new Array(len)” form showed the literal form to be equally fast / minutely faster in both jsc (from WebKit, used in Safari and Google Chrome) and smjs (from SpiderMonkey, used in stable Gecko).

Test and timings: pastie

So, despite what one might intuitively expect, there doesn’t seem to be much difference in speed between the literal form and the sized constructor form.

Ps. JSCore is faaaast(!) (seems too fast, did the JIT optimize away the inner loops or something!??). I’m curious how TraceMonkey will compare.

I have never had occasion to write

var x = [];
x.length = 100;

Using [] does not allow you to set the initial size of an array!!!

You usually don’t have to worry about setting the initial size of an arry, so the shorthand version works well. But there are times when it is necessary to set the initial size of an array; in that case, you have to use the “new Array(x)” format (where x is the number of elements).

(
There is another way to set the initial array size but I think it’s even more ugly and confusing…
var x = [];
x[100] = 0;
)

For most scenarios, the shorthand version is desirable but in situations where you have to set the array size, using new Array() is really your only option.