In JavaScript, why is [ ] preferred over new Array(); ?

Question

I remember reading somewhere (I think it was in one of Crockford's papers) that using an array literal [] is better than using the new Array(); notation.

But I can't really remember any advantages of one over the other.

Can anyone please explain to me on why the former is preferred over the latter?

[Update]

Here is a reason on why [] is better than new Array();:

var Array = function () { };

Overriding the Array object will break code...!

Any more reasons ?

Answer 1

Brevity

It has less bytes to transfer over the wire, less bytes to interpret, less mental resources to parse it.

Less is more.

Consistency

What is the difference between these two lines of code?

var arr = [5];
var arr = new Array(5);

According to here new Array(5); will not return an array with a 5 in it, instead it will return a 5 element array, with all the elements being undefined. Whereas these two lines return identical arrays.

var arr = [5,6];
var arr = new Array(5,6);

Answer 2

1. Javascript is a language that is parsed, not compiled. Thus if you write [] instead of new Array(); The length to parse is shortened.

2. It is much shorter and understood to write [] instead of new Array();

Answer 3

Elegance

To put it simply it just looks nicer AND is easier for a programmer to parse, especially for more complicated data structures:

var a= [
 ['a list', 'of', 'strings'],
 [1, 2, 3, 4],
 { hello: "This is an object property." }
];

Versus the clumsier OOP-oriented method:

var a= new Array();
var a2= new Array();
a2.push('a list');
a2.push('of');
a2.push('strings');
var a3= new Array();
a3.push(1);
a3.push(2);
a3.push(3);
a3.push(4);
var o= new Object();
o.hello= "This is an object property";
a.push(a2, a3, o);

Answer 4

new Array(1, 2, 3) instead of [1, 2, 3] is the same as new String("cow") instead of "cow"

Answer 5

One good reason is because the Array constructor has completely non-intuitive behavior. For example:

var a = new Array(5);
console.log(a.length); //prints "5"
console.log(a[0]); //prints "undefined"

var b = new Array(1,2);
console.log(b.length); //prints "2"
console.log(b[0]); //prints "1"

In this case, a ends up being an array of size 5 with all elements undefined, and b ends up being an array of size 2, with the values [1,2].

var c = new Array("5");
console.log(c.length); //prints "1"
console.log(c[0]); //prints "5"

And here, you end up with a single-element array, containing "5"

In general, you should probably never use the constructors on built-in types in Javascript. They all have weird edge cases like this. For example:

var s = new String("Hello");
var l = "Hello";
console.log(typeof(s)); // prints "object"
console.log(typeof(l)); // prints "string"

Answer 6

Less typing. That's it :)