ja: Format /web/javascript using Prettier (part 7)

files/ja/web/javascript/reference/operators/in/index.md

@@ -12,7 +12,7 @@ slug: Web/JavaScript/Reference/Operators/in
 ## 構文
 
 ```js
-prop in object
+prop in object;
 ```
 
 ### 引数
@@ -30,83 +30,83 @@ prop in object
 
 ```js
 // 配列
-let trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
-0 in trees        // true を返す
-3 in trees        // true を返す
-6 in trees        // false を返す
-'bay' in trees    // false を返す (添字の指す値ではなく、添字の数値を指定しなければならない)
-'length' in trees // true を返す (length は Array のプロパティ)
-Symbol.iterator in trees // true を返す (配列は反復可能。 ES2015 以上で動作する)
+let trees = ["redwood", "bay", "cedar", "oak", "maple"];
+0 in trees; // true を返す
+3 in trees; // true を返す
+6 in trees; // false を返す
+"bay" in trees; // false を返す (添字の指す値ではなく、添字の数値を指定しなければならない)
+"length" in trees; // true を返す (length は Array のプロパティ)
+Symbol.iterator in trees; // true を返す (配列は反復可能。 ES2015 以上で動作する)
 
 // 定義済みオブジェクト
-'PI' in Math          // true を返す
+"PI" in Math; // true を返す
 
 // ユーザー定義オブジェクト
-let mycar = {make: 'Honda', model: 'Accord', year: 1998};
-'make' in mycar  // true を返す
-'model' in mycar // true を返す
+let mycar = { make: "Honda", model: "Accord", year: 1998 };
+"make" in mycar; // true を返す
+"model" in mycar; // true を返す
 ```
 
 `in` 演算子の右側には、オブジェクトを指定しなければなりません。例えば、`String` コンストラクターで作成した文字列は指定できますが、文字列リテラルは指定できません。
 
 ```js
-let color1 = new String('green')
-'length' in color1 // true を返す
+let color1 = new String("green");
+"length" in color1; // true を返す
 
-let color2 = 'coral'
+let color2 = "coral";
 // エラーが発生 (color2 は String オブジェクトではない)
-'length' in color2
+"length" in color2;
 ```
 
 ### 削除済みあるいは未定義状態のプロパティへの `in` の使用
 
 [`delete`](/ja/docs/Web/JavaScript/Reference/Operators/delete) 演算子で削除されたプロパティについては、`in` 演算子は `false` を返します。
 
 ```js
-let mycar = {make: 'Honda', model: 'Accord', year: 1998}
-delete mycar.make
-'make' in mycar   // false を返す
+let mycar = { make: "Honda", model: "Accord", year: 1998 };
+delete mycar.make;
+"make" in mycar; // false を返す
 
-let trees = new Array('redwood', 'bay', 'cedar', 'oak', 'maple')
-delete trees[3]
-3 in trees  // false を返す
+let trees = new Array("redwood", "bay", "cedar", "oak", "maple");
+delete trees[3];
+3 in trees; // false を返す
 ```
 
 {{jsxref("Global_Objects/undefined", "undefined")}} を設定しているが削除されていないプロパティについて、`in` 演算子は true を返します。
 
 ```js
-let mycar = {make: 'Honda', model: 'Accord', year: 1998}
-mycar.make = undefined
-'make' in mycar   // true を返す
+let mycar = { make: "Honda", model: "Accord", year: 1998 };
+mycar.make = undefined;
+"make" in mycar; // true を返す
 ```
 
 ```js
-let trees = new Array('redwood', 'bay', 'cedar', 'oak', 'maple')
-trees[3] = undefined
-3 in trees  // true を返す
+let trees = new Array("redwood", "bay", "cedar", "oak", "maple");
+trees[3] = undefined;
+3 in trees; // true を返す
 ```
 
 `in` 演算子は、空の配列スロットに対して `false` を返します。直接アクセスしても `undefined` が返されます。
 
 ```js
-let empties = new Array(3)
-empties[2] // undefined を返す
-2 in empties  // false を返す
+let empties = new Array(3);
+empties[2]; // undefined を返す
+2 in empties; // false を返す
 ```
 
 これを避けるためには、新しい配列が常に空でない値で埋められるようにするか、配列の終わりを超える位置に書き込まないようにしてください。
 
 ```js
-let empties = new Array(3).fill(undefined)
-2 in empties  // true を返す
+let empties = new Array(3).fill(undefined);
+2 in empties; // true を返す
 ```
 
 ### 継承されたプロパティ
 
 `in` 演算子は、プロトタイプチェーンのプロパティに対して `true` を返します。(*継承されていない*プロパティのみをチェックする場合は、代わりに {{jsxref("Object.prototype.hasOwnProperty()")}} を使用してください)。
 
 ```js
-'toString' in {}  // true を返す
+"toString" in {}; // true を返す
 ```
 
 ### プライベートフィールドとメソッド
@@ -118,17 +118,17 @@ let empties = new Array(3).fill(undefined)
 以下のコードは、指定されたクラスが特定のプライベートメソッドやフィールドを持っているかどうかをチェックする静的関数です。
 
 ```js
-  class ClassWithPrivateFeatures {
-    #a;
-    #b = null;
-    #c() {}
-    get #d() {}
-    static f(o) {
-      return #a in o && #b in o && #c in o && #d in o;
-    }
+class ClassWithPrivateFeatures {
+  #a;
+  #b = null;
+  #c() {}
+  get #d() {}
+  static f(o) {
+    return #a in o && #b in o && #c in o && #d in o;
   }
-  ClassWithPrivateFeatures.f(new ClassWithPrivateFeatures()) // true を返す
-  ClassWithPrivateFeatures.f({}) // false を返す
+}
+ClassWithPrivateFeatures.f(new ClassWithPrivateFeatures()); // true を返す
+ClassWithPrivateFeatures.f({}); // false を返す
 ```
 
 ## 仕様書

files/ja/web/javascript/reference/operators/increment/index.md

@@ -12,8 +12,8 @@ slug: Web/JavaScript/Reference/Operators/Increment
 ## 構文
 
 ```js
-x++
-++x
+x++;
+++x;
 ```
 
 ## 解説

files/ja/web/javascript/reference/operators/inequality/index.md

@@ -12,17 +12,17 @@ slug: Web/JavaScript/Reference/Operators/Inequality
 ## 構文
 
 ```js
-x != y
+x != y;
 ```
 
 ## 解説
 
 不等価演算子は、そのオペランドが等しくないことを検査します。これは[等価](/ja/docs/Web/JavaScript/Reference/Operators/Equality)演算子の逆に当たるので、以下の 2 行は常に同じ結果になります。
 
 ```js
-x != y
+x != y;
 
-!(x == y)
+!(x == y);
 ```
 
 比較アルゴリズムの詳細については、[等価](/ja/docs/Web/JavaScript/Reference/Operators/Equality)演算子のページを参照して下さい。
@@ -44,39 +44,39 @@ x != y
 ### 型変換がない場合の比較
 
 ```js
-1 != 2;              // true
-"hello" != "hola";   // true
+1 != 2; // true
+"hello" != "hola"; // true
 
-1 != 1;              // false
-"hello" != "hello";  // false
+1 != 1; // false
+"hello" != "hello"; // false
 ```
 
 ### 型変換がある場合の比較
 
 ```js
-"1" !=  1;            // false
-1 != "1";             // false
-0 != false;           // false
-0 != null;            // true
-0 != undefined;       // true
-0 != !!null;          // false (論理 NOT 演算子を参照)
-0 != !!undefined;     // false (論理 NOT 演算子を参照)
-null != undefined;    // false
+"1" != 1; // false
+1 != "1"; // false
+0 != false; // false
+0 != null; // true
+0 != undefined; // true
+0 != !!null; // false (論理 NOT 演算子を参照)
+0 != !!undefined; // false (論理 NOT 演算子を参照)
+null != undefined; // false
 
 const number1 = new Number(3);
 const number2 = new Number(3);
-number1 != 3;         // false
-number1 != number2;   // true
+number1 != 3; // false
+number1 != number2; // true
 ```
 
 ### オブジェクトの比較
 
 ```js
-const object1 = {"key": "value"}
-const object2 = {"key": "value"};
+const object1 = { key: "value" };
+const object2 = { key: "value" };
 
-object1 != object2 // true
-object2 != object2 // false
+object1 != object2; // true
+object2 != object2; // false
 ```
 
 ## 仕様書

files/ja/web/javascript/reference/operators/instanceof/index.md

@@ -12,7 +12,7 @@ slug: Web/JavaScript/Reference/Operators/instanceof
 ## 構文
 
 ```js
-object instanceof constructor
+object instanceof constructor;
 ```
 
 ### 引数
@@ -31,30 +31,30 @@ object instanceof constructor
 function C() {}
 function D() {}
 
-let o = new C()
+let o = new C();
 
 // true : Object.getPrototypeOf(o) === C.prototype であるため
-o instanceof C
+o instanceof C;
 
 // false : D.prototype は o のプロトタイプチェーンのどこにも存在しないため
-o instanceof D
+o instanceof D;
 
-o instanceof Object           // true : なぜなら...
-C.prototype instanceof Object // true であるため
+o instanceof Object; // true : なぜなら...
+C.prototype instanceof Object; // true であるため
 
-C.prototype = {}
-let o2 = new C()
+C.prototype = {};
+let o2 = new C();
 
-o2 instanceof C  // true
+o2 instanceof C; // true
 
 // false : C.prototype は o のプロトタイプチェーンの
 // どこにも存在しないため
-o instanceof C
+o instanceof C;
 
-D.prototype = new C()  // 継承を使用
-let o3 = new D()
-o3 instanceof D  // true
-o3 instanceof C  // true : o3 のプロトタイプチェーンに C.prototype があるため
+D.prototype = new C(); // 継承を使用
+let o3 = new D();
+o3 instanceof D; // true
+o3 instanceof C; // true : o3 のプロトタイプチェーンに C.prototype があるため
 ```
 
 なお、 `instanceof` の値の検査結果はコンストラクターの `prototype` プロパティが変化すると変わることがあります。また、オブジェクトのプロトタイプを `Object.setPrototypeOf` を用いて変更した場合や、標準外の `__proto__` プロパティを用いた場合も変わることがあります。
@@ -74,16 +74,16 @@ o3 instanceof C  // true : o3 のプロトタイプチェーンに C.prototype 
 以下の例では、 `instanceof` を `String` オブジェクトに使用した場合の動作を示しています。
 
 ```js
-let literalString = 'これは文字列リテラルです';
-let stringObject  = new String('コンストラクターで作成された String です');
+let literalString = "これは文字列リテラルです";
+let stringObject = new String("コンストラクターで作成された String です");
 
-literalString instanceof String;  // false : 文字列リテラルは String ではない
-stringObject  instanceof String;  // true
+literalString instanceof String; // false : 文字列リテラルは String ではない
+stringObject instanceof String; // true
 
-literalString instanceof Object;  // false : 文字列リテラルは Object ではない
-stringObject  instanceof Object;  // true
+literalString instanceof Object; // false : 文字列リテラルは Object ではない
+stringObject instanceof Object; // true
 
-stringObject  instanceof Date;    // false
+stringObject instanceof Date; // false
 ```
 
 ### instanceof を Date に対して使用
@@ -93,18 +93,17 @@ stringObject  instanceof Date;    // false
 ```js
 let myDate = new Date();
 
-myDate instanceof Date;      // true
-myDate instanceof Object;    // true
-myDate instanceof String;    // false
+myDate instanceof Date; // true
+myDate instanceof Object; // true
+myDate instanceof String; // false
 ```
 
 ### Object.create() で生成された Object
 
 以下の例では、 `instanceof` を `Object.create()` で生成したオブジェクトに使用した場合の動作を示しています。
 
 ```js
-function Shape() {
-}
+function Shape() {}
 
 function Rectangle() {
   Shape.call(this); // スーパークラスのコンストラクターを呼び出す。
@@ -116,18 +115,18 @@ Rectangle.prototype.constructor = Rectangle;
 
 let rect = new Rectangle();
 
-rect instanceof Object;    // true
-rect instanceof Shape;     // true
+rect instanceof Object; // true
+rect instanceof Shape; // true
 rect instanceof Rectangle; // true
-rect instanceof String;    // false
+rect instanceof String; // false
 
-let literalObject     = {};
-let nullObject  = Object.create(null);
+let literalObject = {};
+let nullObject = Object.create(null);
 nullObject.name = "My object";
 
-literalObject    instanceof Object;   // true : すべてのオブジェクトリテラルは Object.prototype をプロトタイプとして持つ
-({})             instanceof Object;   // true : 上記と同じ
-nullObject       instanceof Object;   // false : プロトタイプはプロトタイプチェーンの末尾 (null)
+literalObject instanceof Object; // true : すべてのオブジェクトリテラルは Object.prototype をプロトタイプとして持つ
+({}) instanceof Object; // true : 上記と同じ
+nullObject instanceof Object; // false : プロトタイプはプロトタイプチェーンの末尾 (null)
 ```
 
 ### `mycar` が `Car` 型および `Object` 型であることを示す
@@ -140,9 +139,9 @@ function Car(make, model, year) {
   this.model = model;
   this.year = year;
 }
-let mycar = new Car('Honda', 'Accord', 1998)
-let a = mycar instanceof Car     // true を返す
-let b = mycar instanceof Object  // true を返す
+let mycar = new Car("Honda", "Accord", 1998);
+let a = mycar instanceof Car; // true を返す
+let b = mycar instanceof Object; // true を返す
 ```
 
 ### instanceof の否定