2021/07/26 時点の英語版に同期

1 files changed, 198 insertions, 194 deletions

diff --git a/files/ja/web/javascript/reference/operators/object_initializer/index.md b/files/ja/web/javascript/reference/operators/object_initializer/index.md
index bd7259d336..21b3b36f98 100644
--- a/files/ja/web/javascript/reference/operators/object_initializer/index.md
+++ b/files/ja/web/javascript/reference/operators/object_initializer/index.md
@@ -5,307 +5,311 @@ tags:
   - ECMAScript 2015
   - JSON
   - JavaScript
-  - Literal
-  - Methods
-  - Object
+  - 言語機能
+  - リテラル
+  - メソッド
+  - オブジェクト
   - Primary Expression
   - computed
   - mutation
-  - properties
+  - プロパティ
+browser-compat: javascript.operators.object_initializer
 translation_of: Web/JavaScript/Reference/Operators/Object_initializer
 ---
-<div>{{JsSidebar("Operators")}}</div>
+{{JsSidebar("Operators")}}
 
-<p>オブジェクトは <a href="/ja/docs/Web/JavaScript/Reference/Global_Objects/Object"><code>new Object()</code></a>、<code><a href="/ja/docs/Web/JavaScript/Reference/Global_Objects/Object/create">Object.create()</a></code>、<em>リテラル</em>表記法 (<em>initializer</em> 表記法) を使用して初期化されます。オブジェクト初期化子はオブジェクトのプロパティ名と関連した値のゼロ以上のペアのリストです。中括弧 (<code>{}</code>) で囲まれます。</p>
+オブジェクトは [`new Object()`](/ja/docs/Web/JavaScript/Reference/Global_Objects/Object)、[`Object.create()`](/ja/docs/Web/JavaScript/Reference/Global_Objects/Object/create)、*リテラル*表記法 (*初期化子*表記法) を使用して初期化されます。オブジェクト初期化子はオブジェクトのプロパティ名と関連した値のゼロ以上のペアのリストで、中括弧 (`{}`) で囲まれます。
 
-<div>{{EmbedInteractiveExample("pages/js/expressions-objectinitializer.html")}}</div>
+{{EmbedInteractiveExample("pages/js/expressions-objectinitializer.html", "taller")}}
 
+## 構文
 
+```js
+let o = {}
+let o = {a: 'foo', b: 42, c: {}}
 
-<h2 id="Syntax" name="Syntax">構文</h2>
+let a = 'foo', b = 42, c = {}
+let o = {a: a, b: b, c: c}
 
-<pre class="brush: js">var o = {};
-var o = { a: 'foo', b: 42, c: {} };
-
-var a = 'foo', b = 42, c = {};
-var o = {a: a, b: b, c: c};
-
-var o = {
-  <var>property: function </var>(<var>parameters</var>) {},
-  get <var>property</var>() {},
-  set <var>property</var>(<var>value</var>) {},
+let o = {
+  property: function (parameters) {},
+  get property() {},
+  set property(value) {}
 };
-</pre>
+```
 
-<h3 id="New_notations_in_ECMAScript_2015" name="New_notations_in_ECMAScript_2015">ECMAScript 2015 での新しい表記法</h3>
+### ECMAScript 2015 での新しい表記法
 
-<p>これらの表記をサポートするための互換性の表を参照してください。非サポート環境では、これらの表記は、構文エラーにつながります。</p>
+これらの表記をサポートするための互換性の表を参照してください。非サポート環境では、これらの表記は、構文エラーにつながります。
 
-<pre class="brush: js">// Shorthand property names (ES2015)
-var a = 'foo', b = 42, c = {};
-var o = {a, b, c};
+```js
+// 略記プロパティ名 (ES2015)
+let a = 'foo', b = 42, c = {};
+let o = {a, b, c}
 
-// Shorthand method names (ES2015)
-var o = {
-  <var>property</var>(<var>parameters</var>) {}
-};
+// 略記メソッド名 (ES2015)
+let o = {
+  property(parameters) {}
+}
 
-// Computed property names (ES2015)
-var prop = 'foo';
-var o = {
+// 計算プロパティ名 (ES2015)
+let prop = 'foo';
+let o = {
   [prop]: 'hey',
   ['b' + 'ar']: 'there'
-};</pre>
+}
+```
+
+## 解説
+
+オブジェクト初期化子は、{{jsxref("Object")}} の初期化を表す式です。オブジェクトはオブジェクトを表す*プロパティ*で構成されます。オブジェクトプロパティの値は、特定の[プリミティブ](/ja/docs/Glossary/Primitive)データ型か他のオブジェクトのどちらかを含みます。
 
-<h2 id="Description" name="Description">説明</h2>
+### オブジェクトリテラル表記法 vs JSON
 
-<p>オブジェクト初期化子は、{{jsxref("Object")}} の初期化を表す式です。オブジェクトはオブジェクトを表す<em>プロパティ</em>で構成されます。オブジェクトプロパティの値は特定の {{Glossary("primitive")}} データ型か他のオブジェクトのどちらかを含みます。</p>
+オブジェクトリテラル表記法は **J**ava**S**cript **O**bject **N**otation ([JSON](/ja/docs/Glossary/JSON)) とは異なります。両者は似ていますが、ちがいがあります。
 
-<h3 id="Creating_objects" name="Creating_objects">オブジェクトの生成</h3>
+- JSON は、`"property": value` 構文を使用するプロパティ定義*のみ*を許可します。プロパティ名は二重引用符で囲まなければなりません。そして、その定義を略記にすることはできません。
+- JSON で値とすることができるのは、文字列、数値、配列、`true`、`false`、`null`、別の (JSON) オブジェクトのみです。
+- 関数の値（後述の「メソッド」を参照）は JSON では値を割り当てることができません。
+- {{jsxref("Date")}} のようなオブジェクトは、 {{jsxref("JSON.parse()")}} の後で文字列になります。
+- {{jsxref("JSON.parse()")}} では計算プロパティ名は拒否され、エラーが発生します。
 
-<p>プロパティを持たない空のオブジェクトは下記のように中括弧を記述することで生成されます。</p>
+## 例
 
-<pre class="brush: js">var object = {};</pre>
+### オブジェクトの生成
 
-<p><em>リテラル</em>表記法、<em>initializer</em> 表記法の利点は中括弧内にプロパティをもつオブジェクトをすばやく生成できる点です。また、カンマで区切られた <code>key: value</code> のペアを記述することでプロパティ値の生成も可能です。以下に、三つのプロパティをもつオブジェクトを生成する方法を記します。キーは <code>"foo"</code>、<code>"age"</code>、<code>"baz"</code> であり、各々のキーの値は、文字列の <code>"bar"</code>、数値の <code>42</code> 、そして <code>baz</code> はオブジェクトがプロパティ値となります。</p>
+プロパティを持たない空のオブジェクトは、下記のように中括弧を記述することで生成されます。
 
-<pre class="brush: js">var object = {
+```js
+let object = {}
+```
+
+しかし、*リテラル*記法、*初期化子*記法の利点は、中括弧内にプロパティをもつオブジェクトを簡潔に生成できる点です。 `key: value` の組をカンマで区切ったリストで記述することができます。
+
+以下のコードでは、 `"foo"`、`"age"`、`"baz"` の 3 つのプロパティをもつオブジェクトを生成します。これらのキーの値はそれぞれ、文字列の `"bar"`、数値の `42`、そして他のオブジェクトです。
+
+```js
+let object = {
   foo: 'bar',
   age: 42,
-  baz: {myProp: 12},
-}</pre>
+  baz: {myProp: 12}
+}
+```
 
-<h3 id="Accessing_properties" name="Accessing_properties">プロパティへのアクセス</h3>
+### プロパティへのアクセス
 
-<p>一度オブジェクトを生成した後も、プロパティにアクセスすることができます。その方法は「ドット表記法」か「ブラケット表記法」と言われます。詳細については、<a href="/ja/docs/Web/JavaScript/Reference/Operators/Property_Accessors">プロパティへのアクセス</a>をご覧ください。</p>
+オブジェクトを生成すると、読み取ったり変更したりしたくなるでしょう。オブジェクトのプロパティには、ドット記法またはブラケット記法でアクセスすることができます。（詳細については、[プロパティへのアクセス](/ja/docs/Web/JavaScript/Reference/Operators/Property_Accessors)をご覧ください。）
 
-<pre class="brush: js">object.foo; // "bar"
-object['age']; // 42
+```js
+object.foo // "bar"
+object['age'] // 42
+object.baz          // {myProp: 12}
+object.baz.myProp   //12
+```
 
-object.foo = 'baz';
-</pre>
+### プロパティの定義
 
-<h3 id="Property_definitions" name="Property_definitions">プロパティの定義</h3>
+初期化構文を使用してプロパティを記述する方法について既に学びました。多くの場合、コード内には、オブジェクトに設定したい変数があります。下記のコードをご覧ください。
 
-<p>初期化構文を使用してプロパティを記譜する方法について既に学びました。多くの場合、コード内には、オブジェクトに設定したい変数があります。下記のコードをご覧ください。:</p>
-
-<pre class="brush: js">var a = 'foo',
+```js
+let a = 'foo',
     b = 42,
     c = {};
 
-var o = {
+let o = {
   a: a,
   b: b,
   c: c
-};</pre>
+}
+```
 
-<p>ECMAScript 2015 では、同じことを達成するために利用可能な短い表記があります。:</p>
+ECMAScript 2015 では、同じことを実現するために利用できる短い記法があります。
 
-<pre class="brush: js">var a = 'foo',
+```js
+let a = 'foo',
     b = 42,
     c = {};
 
-// Shorthand property names (ES2015)
-var o = {a, b, c};
+// 略記プロパティ名 (ES2015)
+let o = {a, b, c}
 
 // In other words,
-console.log((o.a === {a}.a)); // true
-</pre>
+console.log((o.a === {a}.a)) // true
+```
 
-<h4 id="Duplicate_property_names" name="Duplicate_property_names">重複したプロパティ名</h4>
+#### 重複したプロパティ名
 
-<p>プロパティに対して同じ名前を使用するとき、二番目のプロパティは最初のプロパティを上書きします。</p>
+プロパティに対して同じ名前を使用するとき、二番目のプロパティは最初のプロパティを上書きします。
 
-<pre class="brush: js">var a = {x: 1, x: 2};
-console.log(a); // {x: 2}
-</pre>
+```js
+let a = {x: 1, x: 2}
+console.log(a) // {x: 2}
+```
 
-<p>ECMAScript 5 の strict モードのコードでは、重複したプロパティの名前は {{jsxref("SyntaxError")}} とみなされます。実行時に重複を可能にする計算されたプロパティ名の導入により、ECMAScript 2015 ではこの制限は取り除かれました。</p>
+ECMAScript 5 の厳格モードのコードでは、重複したプロパティの名前は {{jsxref("SyntaxError")}} とみなされます。実行時に重複を可能にする計算プロパティ名の導入により、 ECMAScript 2015 ではこの制限は取り除かれました。
 
-<pre class="brush: js">function haveES2015DuplicatePropertySemantics() {
+```js
+function haveES2015DuplicatePropertySemantics() {
   'use strict';
   try {
     ({prop: 1, prop: 2});
 
-    // No error thrown, duplicate property names allowed in strict mode
+    // 厳格モードで重複するプロパティ名が許可されているため、エラーが発生しない場合。
     return true;
-  } catch (e) {
-    // Error thrown, duplicates prohibited in strict mode
+  } catch(e) {
+    // 厳格モードで重複が禁止されているため、エラーが発生する場合。
     return false;
   }
-}</pre>
+}
+```
 
-<h3 id="Method_definitions" name="Method_definitions">メソッドの定義</h3>
+### メソッドの定義
 
-<p>オブジェクトのプロパティは <a href="/ja/docs/Web/JavaScript/Reference/Functions">function</a>、<a href="/ja/docs/Web/JavaScript/Reference/Functions/get">getter</a> メソッド、<a href="/ja/docs/Web/JavaScript/Reference/Functions/set">setter </a>メソッドも参照することができます</p>
+オブジェクトのプロパティは[関数](/ja/docs/Web/JavaScript/Reference/Functions)、[ゲッター](/ja/docs/Web/JavaScript/Reference/Functions/get)メソッド、[セッター](/ja/docs/Web/JavaScript/Reference/Functions/set)メソッドも参照することができます。
 
-<pre class="brush: js">var o = {
-  <var>property: function </var>(<var>parameters</var>) {},
-  get <var>property</var>() {},
-  set <var>property</var>(<var>value</var>) {},
-};</pre>
+```js
+let o = {
+  property: function (parameters) {},
+  get property() {},
+  set property(value) {}
+}
+```
 
-<p>ECMAScript 2015 では、省略表記が利用可能です。そのため、キーワード "function" はもはや必要ではありません。</p>
+ECMAScript 2015 では、略記法が利用可能ですので、キーワード "`function`" は必要なくなりました。
 
-<pre class="brush: js">// Shorthand method names (ES2015)
-var o = {
-  <var>property</var>(<var>parameters</var>) {},
-  *<var>generator</var>() {}
-};</pre>
+```js
+// メソッド名の略記法 (ES2015)
+let o = {
+  property(parameters) {},
+}
+```
 
-<p>ECMAScript 2015 では、その値がジェネレーター関数であるプロパティを簡潔に定義する方法があります。:</p>
+ECMAScript 2015 では、ジェネレーター関数であるプロパティを簡潔に定義する方法があります。
 
-<pre class="brush: js">var o = {
-  *<var>generator</var>() {
+```js
+let o = {
+  *generator() {
     ...........
   }
-};</pre>
+};
+```
 
-<p>ECMAScript 5 では、下記のように記述します (しかし、ES5 はジェネレーターを持たないことに注意してください):</p>
+ECMAScript 5 では、下記のように記述します（ただし、 ES5 にはジェネレーターがないことに注意してください）。
 
-<pre class="brush: js">var o = {
-  generator:<var> function* </var>() {
+```js
+let o = {
+  generator: function* () {
     ...........
   }
-};</pre>
+};
+```
+
+メソッドの詳細や例については、[メソッド定義](/ja/docs/Web/JavaScript/Reference/Functions/Method_definitions)をご覧ください。
 
-<p>メソッドの詳細や例については、<a href="/ja/docs/Web/JavaScript/Reference/Functions/Method_definitions">メソッド定義</a>をご覧ください。</p>
+### 計算プロパティ名
 
-<h3 id="Computed_property_names" name="Computed_property_names">計算されたプロパティ名</h3>
+ECMAScript 2015 から、オブジェクト初期化子構文でも、計算プロパティ名に対応します。括弧 `[]` の中に式を記述することができ、それが計算されてプロパティ名として使用されます。これは、プロパティの読み込みと設定に使用したことのある、[プロパティアクセサー](/ja/docs/Web/JavaScript/Reference/Operators/Property_Accessors)構文のブラケット表記を彷彿とさせるものです。
 
-<p>ECMAScript 2015 から、オブジェクト初期化子構文も計算されたプロパティ名をサポートします。括弧 <code>[]</code> の中に式を記述でき、それが計算されてプロパティ名として使用されます。これは、あなたが既にプロパティを読み込んだり設定したりするために使用したことがあるかもしれない、<a href="/ja/docs/Web/JavaScript/Reference/Operators/Property_Accessors">メンバー演算子</a>構文のブラケット表記を思い起こさせます。今では、オブジェクトリテラルでも同様な構文を使うことができます:</p>
+今では、オブジェクトリテラルでも同様な構文を使うことができます。
 
-<pre class="brush: js">// Computed property names (ES2015)
-var i = 0;
-var a = {
+```js
+// Computed property names (ES2015)
+let i = 0
+let a = {
   ['foo' + ++i]: i,
   ['foo' + ++i]: i,
   ['foo' + ++i]: i
-};
+}
+
+console.log(a.foo1) // 1
+console.log(a.foo2) // 2
+console.log(a.foo3) // 3
 
-console.log(a.foo1); // 1
-console.log(a.foo2); // 2
-console.log(a.foo3); // 3
+const items = ["A","B","C"];
+const obj = {
+[items]: "Hello"
+}
+console.log(obj); // A,B,C: "Hello"
+console.log(obj["A,B,C"]) // "Hello"
 
-var param = 'size';
-var config = {
+let param = 'size'
+let config = {
   [param]: 12,
   ['mobile' + param.charAt(0).toUpperCase() + param.slice(1)]: 4
-};
+}
 
-console.log(config); // {size: 12, mobileSize: 4}</pre>
+console.log(config) // {size: 12, mobileSize: 4}
+```
 
-<h3 id="Spread_properties" name="Spread_properties">スプレッドプロパティ</h3>
+### スプレッドプロパティ
 
-<p><a href="https://github.com/tc39/proposal-object-rest-spread">ECMAScript proposal の Rest/Spread プロパティ</a> （ステージ 4） オブジェクトリテラルに<a href="/ja/docs/Web/JavaScript/Reference/Operators/Spread_operator">スプレッド</a>プロパティを追加します。 渡されたオブジェクトから新しいオブジェクトに独自の列挙可能なプロパティをコピーします。</p>
+[ECMAScript proposal の Rest/Spread プロパティ](https://github.com/tc39/proposal-object-rest-spread) （ステージ 4） では、オブジェクトリテラルに[スプレッド](/ja/docs/Web/JavaScript/Reference/Operators/Spread_syntax)プロパティを追加します。 渡されたオブジェクトから新しいオブジェクトに独自の列挙可能なプロパティをコピーします。
 
-<p>{{jsxref("Object.assign()")}} を使うよりも短いコードで prototype を除いた浅いコピーの作成や、マージしたオブジェクトの作成を書けます。</p>
+{{jsxref("Object.assign()")}} を使うよりも短いコードで `prototype` を除いた浅いコピーの作成や、マージしたオブジェクトの作成を書くことができます。
 
-<pre class="brush: js">var obj1 = { foo: 'bar', x: 42 };
-var obj2 = { foo: 'baz', y: 13 };
+```js
+let obj1 = { foo: 'bar', x: 42 }
+let obj2 = { foo: 'baz', y: 13 }
 
-var clonedObj = { ...obj1 };
+let clonedObj = { ...obj1 }
 // Object { foo: "bar", x: 42 }
 
-var mergedObj = { ...obj1, ...obj2 };
-// Object { foo: "baz", x: 42, y: 13 }</pre>
-
-<p>{{jsxref("Object.assign()")}} は <a href="/ja/docs/Web/JavaScript/Reference/Functions/set">setters</a> をトリガーしますが、スプレッド構文はトリガーできません。</p>
-
-<h3 id="Prototype_mutation" name="Prototype_mutation">プロトタイプ変異</h3>
-
-<p><code>__proto__: value</code> 形式、または <code>"__proto__": value</code> 形式のプロパティ定義は、<code>__proto__</code> 名をもつプロパティを生成しません。かわりに、与えられた値がオブジェクトか <a href="/ja/docs/Web/JavaScript/Reference/Global_Objects/null"><code>null</code></a> の場合、その値に生成されたオブジェクトの <code>[[Prototype]]</code> を変更します (その値がオブジェクト、または null ではない場合、オブジェクトは変更されません)。</p>
-
-<pre class="brush: js">var obj1 = {};
-assert(Object.getPrototypeOf(obj1) === Object.prototype);
-
-var obj2 = {__proto__: null};
-assert(Object.getPrototypeOf(obj2) === null);
+let mergedObj = { ...obj1, ...obj2 }
+// Object { foo: "baz", x: 42, y: 13 }
+```
 
-var protoObj = {};
-var obj3 = {'__proto__': protoObj};
-assert(Object.getPrototypeOf(obj3) === protoObj);
+> **Warning:** {{jsxref("Object.assign()")}} は[セッター](/ja/docs/Web/JavaScript/Reference/Functions/set)を起動しますが、スプレッド構文は起動しません。
 
-var obj4 = {__proto__: 'not an object or null'};
-assert(Object.getPrototypeOf(obj4) === Object.prototype);
-assert(!obj4.hasOwnProperty('__proto__'));
-</pre>
+### プロトタイプの変更
 
-<p>単一のプロトタイプの変異のみ、オブジェクトリテラルに許可されています: すなわち、複数のプロトタイプの変異は構文エラーです。</p>
+`__proto__: value` 形式、または `"__proto__": value` 形式でプロパティを定義しても、 `__proto__` という名をもつプロパティを生成しません。代わりに、与えられた値がオブジェクトまたは [`null`](/ja/docs/Web/JavaScript/Reference/Global_Objects/null) の場合、その値に生成されたオブジェクトの `[[Prototype]]` を変更します（その値がオブジェクト、または null ではない場合、オブジェクトは変更されません）。
 
-<p>"colon" 表記法を使用しないプロパティ定義はプロトタイプ変異ではありません。:  任意の他の名称を使用する同様の定義と同じように動作するプロパティ定義です。</p>
+```js
+let obj1 = {}
+assert(Object.getPrototypeOf(obj1) === Object.prototype)
 
-<pre class="brush: js">var __proto__ = 'variable';
+let obj2 = {__proto__: null}
+assert(Object.getPrototypeOf(obj2) === null)
 
-var obj1 = {__proto__};
-assert(Object.getPrototypeOf(obj1) === Object.prototype);
-assert(obj1.hasOwnProperty('__proto__'));
-assert(obj1.__proto__ === 'variable');
+let protoObj = {}
+let obj3 = {'__proto__': protoObj}
+assert(Object.getPrototypeOf(obj3) === protoObj)
 
-var obj2 = {__proto__() { return 'hello'; }};
-assert(obj2.__proto__() === 'hello');
+let obj4 = {__proto__: 'not an object or null'}
+assert(Object.getPrototypeOf(obj4) === Object.prototype)
+assert(!obj4.hasOwnProperty('__proto__'))
+```
 
-var obj3 = { ['__prot' + 'o__']: 17 };
-assert(obj3.__proto__ === 17);
-</pre>
+オブジェクトリテラルでは、単一のプロトタイプの変更のみが許可されています。すなわち、複数のプロトタイプを変更すると構文エラーになります。
 
-<h2 id="Object_literal_notation_vs_JSON" name="Object_literal_notation_vs_JSON">オブジェクトリテラル表記法 vs JSON</h2>
+「コロン」表記法を使用しないプロパティ定義は、プロトタイプの変更にはなりません。任意の他の名称を使用する同様の定義と同じように動作するプロパティ定義です。
 
-<p>オブジェクトリテラル表記法は <strong>J</strong>ava<strong>S</strong>cript <strong>O</strong>bject <strong>N</strong>otation (<a href="/ja/docs/Glossary/JSON">JSON</a>) とは異なります。それらは似ていますが、それらの間には違いがあります。:</p>
+```js
+let __proto__ = 'variable'
 
-<ul>
- <li>JSON は、<code>"property": value</code> 構文を使用するプロパティ定義<em>のみ</em>許可します。プロパティ名称は二重引用符で囲まなければなりません。そして、その定義は簡略にすることはできません。</li>
- <li>JSON ではその値は strings、numbers、arrays、<code>true</code>、<code>false</code>、<code>null</code>、別の (JSON) オブジェクトのみです。</li>
- <li>関数の値 (上記"{{anch("Method definitions", "メソッド")}}"を参照) は JSON では値を割り当てることができません。</li>
- <li>{{jsxref("Date")}} のようなオブジェクトは {{jsxref("JSON.parse()")}} の後で string になります。</li>
- <li>{{jsxref("JSON.parse()")}} は計算されたプロパティ名を拒否し、エラーがスローされます。</li>
-</ul>
+let obj1 = {__proto__}
+assert(Object.getPrototypeOf(obj1) === Object.prototype)
+assert(obj1.hasOwnProperty('__proto__'))
+assert(obj1.__proto__ === 'variable')
 
-<h2 id="Specifications" name="Specifications">仕様</h2>
+let obj2 = {__proto__() { return 'hello'; }}
+assert(obj2.__proto__() === 'hello')
 
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">仕様</th>
-   <th scope="col">ステータス</th>
-   <th scope="col">コメント</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>初期定義。</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-11.1.5', 'Object Initializer')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td><a href="/ja/docs/Web/JavaScript/Reference/Functions/get">getter</a> と <a href="/ja/docs/Web/JavaScript/Reference/Functions/set">setter</a> が追加されました。</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-object-initializer', 'Object Initializer')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>簡略表現メソッド/プロパティの名称と計算されたプロパティ名が追加されました。</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-object-initializer', 'Object Initializer')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
+let obj3 = {['__prot' + 'o__']: 17}
+assert(obj3.__proto__ === 17)
+```
 
-<h2 id="Browser_compatibility" name="Browser_compatibility">ブラウザー実装状況</h2>
+## 仕様書
 
-<div>
+{{Specifications}}
 
+## ブラウザーの互換性
 
-<p>{{Compat("javascript.operators.object_initializer")}}</p>
-</div>
+{{Compat}}
 
-<h2 id="See_also" name="See_also">関連情報</h2>
+## 関連情報
 
-<ul>
- <li><a href="/ja/docs/Web/JavaScript/Reference/Operators/Property_Accessors">メンバー演算子</a></li>
- <li><code><a href="/ja/docs/Web/JavaScript/Reference/Functions/get">get</a></code> / <code><a href="/ja/docs/Web/JavaScript/Reference/Functions/set">set</a></code></li>
- <li><a href="/ja/docs/Web/JavaScript/Reference/Functions/Method_definitions">メソッド定義</a></li>
- <li><a href="/ja/docs/Web/JavaScript/Reference/Lexical_grammar">字句文法</a></li>
-</ul>
+- [メンバー演算子](/ja/docs/Web/JavaScript/Reference/Operators/Property_Accessors)
+- [`get`](/ja/docs/Web/JavaScript/Reference/Functions/get) / [`set`](/ja/docs/Web/JavaScript/Reference/Functions/set)
+- [メソッド定義](/ja/docs/Web/JavaScript/Reference/Functions/Method_definitions)
+- [字句文法](/ja/docs/Web/JavaScript/Reference/Lexical_grammar)