Javascript object initialization, which is the best way to do it?

Question

Object initialization:

var myObject = {};

and

var myObject = new Object();

why the last one is considered an antipattern?

thanks

Answer 1

I'm not sure new Object() really falls under "anti-pattern", but {} is usually preferred, it's terse and more flexible at the same time.

When you're writing JavaScript you want it to end up short...if it can be terse and understandable when writing it as well, as this is:

var myObject = { key: "value" };

...then you get the best of both worlds. Also when you're creating objects within objects, for example:

var myObject = { subObj: { key: "value" } };

...then you can see it's much more readable than the alternative new Object() syntax.

Answer 2

You always should prefer literals over constructors.

This is not really related to your question but here is an example with arrays. new Array() can be confusing at the first glance if you don't know how it works:

var a = [5,6];
var b = [5];

both create arrays with length 2 and 1 resp. But consider

var a = new Array(5,6);
var b = new Array(5);

The first one creates an array of length 2 ,containing the elements 5 and 6, the last one creates an empty array of length 5.

So you see, using literal notation avoids this pitfall.

Besides that, always using literal notation is consistent. When you create a string you also write var t = "Hello world" and not var t = new String("Hello world") .

Answer 3

由于数组构造函数的问题，反模式很好，只是仍然使用文字{} ，而不是对象new Object的构造函数， 请参阅Google Javascript指南 。

Answer 4

Almost Always, yes

I think saying things like "one should always prefer this" is a bit too generalized, there are always exceptions. Object literals are almost always preferred, but what to do when you are trying to clone complex sets of objects?? Or trying to instantiate module ?

if (typeof Object.create !== 'function') {
    Object.create = function (o) {
        function F() {}
        F.prototype = o;
        return new F();
    };
}
newObject = Object.create(oldObject);