`new Object（）`とオブジェクトリテラル表記の違いは何ですか？

オブジェクトを作成するためのこのコンストラクタベースの構文の違いは何ですか？

person = new Object()

...そしてこのリテラル構文：

person = {
    property1 : "Hello"
};

JSLintではオブジェクトリテラル表記の使用を推奨していますが、どちらも同じことを行うようです。

どっちがいいの？なぜ？

2番目のオブジェクトがオブジェクトを作成することを除いて、どちらも（誰かが異常なことをしない限り）同じことを行います をてプロパティを追加する。しかし、リテラル表記はソースコード内のスペースが少なくて済みます。何が起こっているのかは明確に認識できるため、を使用すると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"
};

技術的には同じことをしないでください。1つ目はオブジェクトを作成するだけです。2番目は1つを作成し、プロパティを割り当てます。最初のものを同じにするには、プロパティを作成して割り当てるための2番目の手順が必要です。

誰かができる「異常なこと」は、デフォルトのObjectグローバルにシャドウするか割り当てることです。

// Don't do this
Object = 23;

その非常に珍しいケースでnew Objectは、失敗します{}が動作します。

実際には、使用する理由があることはないnew Objectのではなく{}（あなたがその非常に珍しい事をやった場合を除きます）。

あなたの例のようにメソッドのない単純なオブジェクトの違いはありません。ただし、オブジェクトにメソッドを追加し始めると、大きな違いがあります。

文字通りの方法：

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 foo = new Obj( "hello" ); 

ただし、文字通りの方法でsayHelloは、オブジェクトの各インスタンス内でメソッドのコピーを保持します。一方、プロトタイプの方法では、メソッドはオブジェクトプロトタイプで定義され、すべてのオブジェクトインスタンス間で共有されます。 多くのオブジェクトまたは多くのメソッドがある場合、文字通りの方法は非常に大きなメモリの浪費につながる可能性があります。

JavaScriptでは、次の2つの方法で新しい空のオブジェクトを宣言できます。

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

これら2つが舞台裏でどのように動作するかに関して、これら2つに大きな違いがあることを示唆するものは何もありません（私が間違っている場合は修正してください-知りたいです）。ただし、2番目の方法（オブジェクトリテラル表記を使用）にはいくつかの利点があります。

1. 短い（正確には10文字）
2. オンザフライでオブジェクトを作成する方が簡単で構造化されています
3. 一部の道化師が誤ってオブジェクトをオーバーライドしたかどうかは関係ありません

メンバーNameとTelNoを含む新しいオブジェクトを考えます。新しいObject（）規約を使用して、次のように作成できます。

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

ExpandoプロパティJavaScript機能を使用すると、このようにその場で新しいメンバーを作成でき、意図したとおりの結果が得られます。ただし、この方法はあまり構造化もカプセル化もされていません。作成時に、expandoプロパティや割り当て後の割り当てに依存することなく、メンバーを指定したい場合はどうでしょうか。

これは、オブジェクトリテラル表記が役立つ場所です。

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

ここでは、1行のコードで文字数を大幅に減らし、同じ効果を実現しています。

上記のオブジェクト構築メソッドの詳細については、JavaScriptおよびオブジェクト指向プログラミング（OOP）を参照してください。

そして最後に、オブジェクトをオーバーライドしたバカはどうですか？それは不可能だと思いましたか？そうですね、このJSFiddleはそれ以外のことを証明しています。オブジェクトリテラル表記を使用すると、このバッファローのファウルに陥るのを防ぐことができます。

（http://www.jameswiseman.com/blog/2011/01/19/jslint-messages-use-the-object-literal-notation/から）

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');

これは、ここにあるものの拡張であることに注意してください。なぜarr = []がarr = new Arrayより速いのですか？

私の出力は次のとおりでした：

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

明らかに、{}と[]はnewを使用して空のオブジェクト/配列を作成するよりも高速です。

ここの誰もが2つの類似点について話している。違いを指摘しておきます。

1. を使用new Object()すると、別のオブジェクトを渡すことができます。明らかな結果は、新しく作成されたオブジェクトが同じ参照に設定されることです。これがサンプルコードです：

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

2. 使用方法は、OOPオブジェクトのようにオブジェクトに限定されません。他のタイプもそれに渡すことができます。関数はそれに応じてタイプを設定します。たとえば、整数1を渡すと、number型のオブジェクトが作成されます。

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

3. 上記のメソッド（new Object(1)）を使用して作成されたオブジェクトは、プロパティが追加されるとオブジェクトタイプに変換されます。

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

4. オブジェクトがオブジェクトの子クラスのコピーである場合、型変換なしでプロパティを追加できます。

   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

実際、JavaScriptでオブジェクトを作成する方法はいくつかあります。オブジェクトを作成したいだけの場合、「new」演算子を使用して「コンストラクタベースの」オブジェクトを作成するメリットはありません。「オブジェクトリテラル」構文を使用してオブジェクトを作成するのと同じです。しかし、「プロトタイプの継承」について考えていると、「new」演算子で作成された「コンストラクタベースの」オブジェクトが信じられないほど使用されます。リテラル構文で作成されたオブジェクトの継承チェーンは維持できません。ただし、コンストラクター関数を作成し、そのプロトタイプにプロパティとメソッドをアタッチできます。"演算子、それはそのコンストラクター関数のプロトタイプに添付されたすべてのメソッドとプロパティにアクセスできるオブジェクトを返します。

コンストラクター関数を使用してオブジェクトを作成する例を次に示します（下部のコードの説明を参照）。

function Person(firstname, lastname) {
    this.firstname = firstname;
    this.lastname = lastname;
}

Person.prototype.fullname = function() {
    console.log(this.firstname + ' ' + this.lastname);
}

var zubaer = new Person('Zubaer', 'Ahammed');
var john = new Person('John', 'Doe');

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

これで、Person構築関数をインスタンス化することで、必要な数のオブジェクトを作成でき、それらすべてからfullname（）が継承されます。

注：「this」キーワードはコンストラクター関数内の空のオブジェクトを参照し、「new」演算子を使用してPersonから新しいオブジェクトを作成すると、「this」キーワードが付加されたすべてのプロパティとメソッドを含むオブジェクトを自動的に返します。そして、これらのオブジェクトは確実に、Personコンストラクター関数のプロトタイプにアタッチされたメソッドとプロパティを継承します（これがこのアプローチの主な利点です）。

ちなみに、「オブジェクトリテラル」構文で同じ機能を取得したい場合は、以下のようにすべてのオブジェクトにfullname（）を作成する必要があります。

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();

最後に、なぜオブジェクトリテラルアプローチではなくコンストラクタ関数アプローチを使用する必要があるのか​​を尋ねた場合：

***プロトタイプの継承により、非常に便利で強力な継承の単純なチェーンが可能になります。

***コンストラクター関数プロトタイプで定義された共通のメソッドとプロパティを継承することにより、メモリを節約します。それ以外の場合は、すべてのオブジェクトでそれらを何度もコピーする必要があります。

これが理にかなっているといいのですが。

また、一部のO'Really JavaScriptブックによると...（引用）

Objectコンストラクターとは対照的にリテラルを使用するもう1つの理由は、スコープ解決がないためです。同じ名前のローカルコンストラクターを作成した可能性があるため、インタープリターは、Object（）を呼び出している場所から、グローバルオブジェクトコンストラクターが見つかるまで、スコープチェーンを検索する必要があります。

ES6 / ES2015について、1つの違いを発見しました。オブジェクトをで囲まない限り、簡略矢印関数構文を使用してオブジェクトを返すことはできませんnew Object()。

> [1, 2, 3].map(v => {n: v});
[ undefined, undefined, undefined ]
> [1, 2, 3].map(v => new Object({n: v}));
[ { n: 1 }, { n: 2 }, { n: 3 } ]

これは、コンパイラーが{}大括弧で混乱し、label：ステートメント構造で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 :

2019アップデート

OSX High Sierra 10.13.6ノードバージョン10.13.0で@rjlouraと同じコードを実行しました。これらは結果です

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

1万個のインスタンスを作成すると、メモリ使用量は異なります。 new Object()1部のみを保持し、1 {}万部を保持します。