Javascript “new Object（）”和对象文字符号有什么区别？

用于创建对象的基于构造函数的语法之间有什么区别：

person = new Object()

…而这种文字语法：

person = {
    property1 : "Hello"
};

虽然JSLint更喜欢使用对象文字符号，但两者似乎做了相同的事情

---

哪一个更好？为什么？

它们都做相同的事情（除非有人做了不寻常的事情），除了第二个创建对象并向其添加属性之外。但是文字符号在源代码中占用的空间更少。可以清楚地识别发生了什么，因此使用

new Object（）

，您实际上只是输入了更多的内容，并且（理论上，如果没有通过JavaScript引擎优化的话）执行了一个不必要的函数调用

这些

person = new Object() /*You should put a semicolon here too.  
It's not required, but it is good practice.*/ 
-or-

person = {
    property1 : "Hello"
};

从技术上讲，不要做同样的事情。第一个只是创建一个对象。第二个创建一个并指定一个属性。要使第一个属性相同，则需要第二步来创建和分配属性

有人可以做的“不寻常的事情”是对默认的

对象进行阴影处理或赋值

全局：

// Don't do this
Object = 23;

在这种极不寻常的情况下，

新对象

将失败，但

{}

将工作

---

实际上，没有理由使用

新对象而不是
{}
（除非您做了非常不寻常的事情）。
在JavaScript中，我们可以通过两种方式声明新的空对象：

var obj1 = new Object();  
var obj2 = {};  

我没有发现任何迹象表明，这两个人在幕后的运作方式有任何重大差异（如果我错了，请纠正我——我很想知道）。然而，第二种方法（使用对象文字符号）提供了一些优点

它较短（精确地说是10个字符）
动态创建对象更容易、更结构化
如果某个小丑无意中覆盖了对象，这并不重要
考虑一个包含成员名称和TelNo的新对象。使用new Object（）约定，我们可以如下创建它：

var obj1 = new Object();  
obj1.Name = "A Person";  
obj1.TelNo = "12345"; 

var foo = new Obj( "hello" ); 

JavaScript的特性允许我们以这种方式动态地创建新成员，我们实现了我们的预期。然而，这种方式不是很结构化或封装的。如果我们希望在创建时指定成员，而不必依赖expando属性和创建后分配，该怎么办

这就是对象文字符号可以帮助的地方：

var obj1 = {Name:"A Person",TelNo="12345"};  

在这里，我们在一行代码中实现了相同的效果，并且显著减少了字符数

有关上述对象构造方法的进一步讨论，请访问：

最后一点，那个超越客体的白痴怎么办？你认为这不可能吗？事实证明并非如此。使用object-literal表示法可以防止我们与这个滑稽动作相冲突

（From）
没有方法的简单对象与示例中的方法没有区别。
但是，当您开始向对象添加方法时，会有很大的不同

文字方式：

function Obj( prop ) { 
    return { 
        p : prop, 
        sayHello : function(){ alert(this.p); }, 
    }; 
} 

原型方式：

function Obj( prop ) { 
    this.p = prop; 
} 
Obj.prototype.sayHello = function(){alert(this.p);}; 

这两种方法都允许创建如下所示的
Obj
实例：

var obj1 = new Object();  
obj1.Name = "A Person";  
obj1.TelNo = "12345"; 

var foo = new Obj( "hello" ); 

但是，使用literal方式，您可以在对象的每个实例中携带
sayHello
方法的副本。然而，通过原型方式，该方法在对象原型中定义，并在所有对象实例之间共享。
如果您有很多对象或方法，文字方式可能会导致相当大的内存浪费。
这里的每个人都在谈论这两者的相似之处。我要指出区别

使用
newobject（）
可以传递另一个对象。显而易见的结果是，新创建的对象将被设置为相同的引用。下面是一个示例代码：

var obj1 = new Object();
obj1.a = 1;
var obj2 = new Object(obj1);
obj2.a // 1


这种用法不限于OOP对象中的对象。其他类型也可以传递给它。该函数将相应地设置类型。例如，如果我们将整数1传递给它，将为我们创建一个number类型的对象

var obj = new Object(1);
typeof obj // "number"


如果向使用上述方法创建的对象（
新对象（1）
）添加属性，则该对象将转换为对象类型

var obj = new Object(1);
typeof obj // "number"
obj.a = 2;
typeof obj // "object"


如果对象是对象的子类的副本，我们可以添加属性而不进行类型转换

var obj = new Object("foo");
typeof obj // "object"
obj === "foo" // true
obj.a = 1;
obj === "foo" // true
obj.a // 1
var str = "foo";
str.a = 1;
str.a // undefined


另外，根据O'Really javascript的一些书……（引用）

使用文本而不是对象构造函数的另一个原因是没有范围解析。因为您可能创建了同名的本地构造函数，所以解释器需要从调用Object（）的位置一直查找作用域链，直到找到全局对象构造函数为止
 在我使用Node.js的机器上，我运行了以下程序：

console.log('Testing Array:');
console.time('using[]');
for(var i=0; i<200000000; i++){var arr = []};
console.timeEnd('using[]');

console.time('using new');
for(var i=0; i<200000000; i++){var arr = new Array};
console.timeEnd('using new');

console.log('Testing Object:');

console.time('using{}');
for(var i=0; i<200000000; i++){var obj = {}};
console.timeEnd('using{}');

console.time('using new');
for(var i=0; i<200000000; i++){var obj = new Object};
console.timeEnd('using new');

Testing Array:
using[]: 1091ms
using new: 2286ms
Testing Object:
using{}: 870ms
using new: 5637ms

因此，{}和[]显然比使用new创建空对象/数组要快。
我发现了一个区别，那就是ES6/ES2015。除非使用
newobject（）
环绕对象，否则不能使用速记箭头函数语法返回对象

这是因为编译器被
{}
括号弄糊涂了，认为
n:i
是一个构造；分号是可选的，因此它不会抱怨它

如果向对象添加另一个属性，它最终将抛出错误

$ node -e "[1, 2, 3].map(v => {n: v, m: v+1});"
[1, 2, 3].map(v => {n: v, m: v+1});
                           ^

SyntaxError: Unexpected token :

如果创建10000个实例，内存使用情况会有所不同。
newobject（）
将只保留一个副本，而
{}
将保留10000个副本。
实际上，有几种方法可以在JavaScript中创建对象。当您只想创建一个对象时，使用“new”操作符创建基于构造函数的对象没有任何好处。这与使用“object literal”语法创建对象相同。但是，当您考虑“原型继承”时，使用“新建”操作符创建的“基于构造函数的”对象就有了难以置信的用途
var zubaer = {
    firstname: 'Zubaer',
    lastname: 'Ahammed',
    fullname: function() {
        console.log(this.firstname + ' ' + this.lastname);
    }
};

var john= {
    firstname: 'John',
    lastname: 'Doe',
    fullname: function() {
        console.log(this.firstname + ' ' + this.lastname);
    }
};

zubaer.fullname();
john.fullname();

console.log('Testing Array:');
console.time('using[]');
for(var i=0; i<200000000; i++){var arr = []};
console.timeEnd('using[]');

console.time('using new');
for(var i=0; i<200000000; i++){var arr = new Array};
console.timeEnd('using new');

console.log('Testing Object:');

console.time('using{}');
for(var i=0; i<200000000; i++){var obj = {}};
console.timeEnd('using{}');

console.time('using new');
for(var i=0; i<200000000; i++){var obj = new Object};
console.timeEnd('using new');


Testing Array:
using[]: 117.613ms
using new: 117.168ms
Testing Object:
using{}: 117.205ms
using new: 118.644ms

() => new Object({ key: value})

() => { key: value} //  instead of () => { return { key: value};}