From 421527e0bbd024b162b267415960aacc31ce8b68 Mon Sep 17 00:00:00 2001 From: Masahiro FUJIMOTO Date: Thu, 17 Feb 2022 02:10:05 +0900 Subject: 2022/01/18 時点の英語版に同期 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../reference/operators/instanceof/index.md | 221 +++++++++++---------- 1 file changed, 117 insertions(+), 104 deletions(-) (limited to 'files') diff --git a/files/ja/web/javascript/reference/operators/instanceof/index.md b/files/ja/web/javascript/reference/operators/instanceof/index.md index a238d8b522..d2cab1f7ab 100644 --- a/files/ja/web/javascript/reference/operators/instanceof/index.md +++ b/files/ja/web/javascript/reference/operators/instanceof/index.md @@ -3,125 +3,148 @@ title: instanceof slug: Web/JavaScript/Reference/Operators/instanceof tags: - JavaScript - - Language feature - - Object - - Operator - - Prototype - - Relational Operators + - 言語機能 + - オブジェクト + - 演算子 + - プロトタイプ + - 関連演算子 - instanceof +browser-compat: javascript.operators.instanceof translation_of: Web/JavaScript/Reference/Operators/instanceof --- -
{{jsSidebar("Operators")}}
+{{jsSidebar("Operators")}} -

instanceof 演算子は、オブジェクトが自身のプロトタイプにコンストラクタの prototype プロパティを持っているかを確認します。戻り値はブール値です。

+**`instanceof` 演算子**は、あるコンストラクターの `prototype` プロパティが、あるオブジェクトのプロトタイプチェーンの中のどこかに現れるかどうかを検査します。返値は論理値です。 -
{{EmbedInteractiveExample("pages/js/expressions-instanceof.html")}}
+{{EmbedInteractiveExample("pages/js/expressions-instanceof.html")}} +## 構文 +```js +object instanceof constructor +``` -

構文

+### 引数 -
object instanceof constructor
+- `object` + - : 検査するオブジェクトです。 +- `constructor` + - : 検査対象の関数です。 -

引数

+## 解説 -
-
object
-
確認するオブジェクト
-
+`instanceof` 演算子は、`object` のプロトタイプチェーンに `constructor.prototype` が存在することを検査します。 -
-
constructor
-
オブジェクトに対して確認を行う関数
-
- -

説明

- -

instanceof 演算子は、object のプロトタイプチェインで constructor.prototype の存在を確認します。

- -
// コンストラクタを定義
+```js
+// コンストラクターを定義
 function C() {}
 function D() {}
 
 let o = new C()
 
-// true なぜなら: Object.getPrototypeOf(o) === C.prototype
-o instanceof C;
+// true : Object.getPrototypeOf(o) === C.prototype であるため
+o instanceof C
 
-// false D.prototype は o のプロトタイプチェーンのどこにも存在しない
-o instanceof D;
+// false : D.prototype は o のプロトタイプチェーンのどこにも存在しないため
+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()
 
-o2 instanceof C; // true
+o2 instanceof C  // true
 
-// false C.prototype は o のプロトタイプチェーンの
-// どこにも存在しない
-o instanceof C;
+// false : C.prototype は o のプロトタイプチェーンの
+// どこにも存在しないため
+o instanceof C
 
-D.prototype = new C(); // 継承を使用
+D.prototype = new C()  // 継承を使用
 let o3 = new D()
-o3 instanceof D; // true
-o3 instanceof C; // true o3 のプロトタイプチェーンに C.prototype があるため。
-
+o3 instanceof D // true +o3 instanceof C // true : o3 のプロトタイプチェーンに C.prototype があるため +``` + +なお、 `instanceof` の値の検査結果はコンストラクターの `prototype` プロパティが変化すると変わることがあります。また、オブジェクトのプロトタイプを `Object.setPrototypeOf` を用いて変更した場合や、標準外の `__proto__` プロパティを用いた場合も変わることがあります。 + +### `instanceof` と複数のコンテキスト (例: frame や window) -

注意事項: instanceof による確認結果はコンストラクタの prototype プロパティの変化に従って変わることがあります。また、オブジェクトのプロトタイプを Object.setPrototypeOf を用いて変更した場合や、非標準の __proto__ 疑似プロパティを用いた場合も変わりえます。

+スコープが異なると、実行環境が変わります。つまり、組み込まれているものも変わります（別々なグローバルオブジェクト、別々なコンストラクター、など）。これにより予期せぬ結果になる場合があります。例えば、`[] instanceof window.frames[0].Array` は `false` を返します。 `Array.prototype !== window.frames[0].Array.prototype` であり、配列は前者を継承しているからです。 -

instanceof と複数のコンテキスト (例: frame や window)

+これは、始めはわかりにくいかもしれませんが、スクリプトで複数のフレームやウィンドウを扱い、オブジェクトをあるコンテキストから別のコンテキストへ関数を経由して渡すようになると、正当かつ重要な事項になります。例えば、`Array.isArray(myObj)` を使用すると、与えられたオブジェクトが実際に配列であるかどうかを安全にチェックできます。 -

異なるスコープは、別々の実行環境を持ちます。つまり、それらは別々の組み込み物 (別々のグローバルオブジェクト、別々のコンストラクタ 等々) を持ちます。これにより予期せぬ結果になる場合があります。例えば、[] instanceof window.frames[0].Array は、Array.prototype !== window.frames[0].Array であることおよび配列が以前から継承していることから false を返します。

+例えば、別のコンテキストで [Node](/ja/docs/Web/API/Node) が [SVGElement](/ja/docs/Web/API/SVGElement) であるかどうかをチェックするには、`myNode instanceof myNode.ownerDocument.defaultView.SVGElement` を使用してください。 -

これは、始めはわかりにくいかもしれませんが、スクリプトで複数のフレームやウィンドウを扱い始め、オブジェクトをあるコンテキストから別のコンテキストへ関数を経由して渡すようになると、正当かつ重要な事項になります。例えば、Array.isArray(myObj) を使用して、与えられたオブジェクトが実際に配列であるかどうかを安全にチェックできます。

+## 例 -

例えば、別のコンテキストで Nodes が SVGElement であるかどうかをチェックするには、myNode instanceof myNode.ownerDocument.defaultView.SVGElement を使用します。

+### instanceof を String に対して使用 -
-

Mozilla 開発者への注意点

+以下の例では、 `instanceof` を `String` オブジェクトに使用した場合の動作を示しています。 -

XPCOM を用いるコードでは instanceof に特別な効果があります: obj instanceof xpcomInterface (例えば Components.interfaces.nsIFile) は obj.QueryInterface(xpcomInterface) を呼び出し、QueryInterface が成功した場合に true を返します。

+```js +let literalString = 'これは文字列リテラルです'; +let stringObject = new String('コンストラクターで作成された String です'); -

このような呼び出しの副作用として、instanceof による確認の成功後に obj の xpcomInterface のプロパティを利用できることがあります。標準 JavaScript の環境と異なり、obj が異なるスコープ由来であっても obj instanceof xpcomInterface での確認は期待どおりに動作します。

-
+literalString instanceof String; // false : 文字列リテラルは String ではない +stringObject instanceof String; // true -

例

+literalString instanceof Object; // false : 文字列リテラルは Object ではない +stringObject instanceof Object; // true -

String や Date が Object タイプであることの実証

+stringObject instanceof Date; // false +``` -

以下のコードは、String や Date オブジェクトが Object タイプでもある (Object から派生している) ことの実証に instanceof を用いています。

+### instanceof を Date に対して使用 -

また、オブジェクトリテラルを用いて作成されたオブジェクトに対する例外、つまり、prototype が undefined であるにも関わらず instanceof Object が true を報告する例を示します。

+以下の例では、 `instanceof` を `Date` オブジェクトに使用した場合の動作を示しています。 -
let simpleStr = 'This is a simple string'
-let myString  = new String()
-let newStr    = new String('コンストラクターで作成された文字列')
-let myDate    = new Date()
-let myObj     = {}
-let myNonObj  = Object.create(null)
+```js
+let myDate = new Date();
 
-simpleStr instanceof String  // false を返す 文字列リテラルはオブジェクトではありません。
-myString  instanceof String  // true を返す
-newStr    instanceof String  // true を返す
-myString  instanceof Object  // true を返す
+myDate instanceof Date;      // true
+myDate instanceof Object;    // true
+myDate instanceof String;    // false
+```
 
-myObj    instanceof Object   // true を返す すべてのオブジェクトリテラルはプロトタイプとして Object.prototype を持っています。
-({})     instanceof Object   // true を返す 上記と同じ
-myNonObj instanceof Object   // false を返す プロトタイプはプロトタイプチェーンの終わりです（null）
-myString instanceof Date     // false を返す
+### Object.create() で生成された Object
 
-myDate instanceof Date      // true を返す
-myDate instanceof Object    // true を返す
-myDate instanceof String    // false を返す
-
+以下の例では、 `instanceof` を `Object.create()` で生成したオブジェクトに使用した場合の動作を示しています。 + +```js +function Shape() { +} + +function Rectangle() { + Shape.call(this); // スーパークラスのコンストラクターを呼び出す。 +} -

mycar が Car タイプおよび Object タイプであることの実証

+Rectangle.prototype = Object.create(Shape.prototype); -

以下のコードは、Car オブジェクトタイプとそのインスタンスである mycar を生成しています。instanceof 演算子で、mycar は Car タイプおよび Object タイプであることを実証します。

+Rectangle.prototype.constructor = Rectangle; -
function Car(make, model, year) {
+let rect = new Rectangle();
+
+rect instanceof Object;    // true
+rect instanceof Shape;     // true
+rect instanceof Rectangle; // true
+rect instanceof String;    // false
+
+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)
+```
+
+### `mycar` が `Car` 型および `Object` 型であることを示す
+
+以下のコードは、`Car` オブジェクト型とそのインスタンスである `mycar` を生成しています。`instanceof` 演算子で、`mycar` は `Car` 型および `Object` 型であることを示します。
+
+```js
+function Car(make, model, year) {
   this.make = make;
   this.model = model;
   this.year = year;
@@ -129,47 +152,37 @@ myDate instanceof String    // false を返す
 let mycar = new Car('Honda', 'Accord', 1998)
 let a = mycar instanceof Car     // true を返す
 let b = mycar instanceof Object  // true を返す
-
+``` -

インスタンスではないことの実証

+### instanceof の否定 -

オブジェクトが特定のコンストラクタの instanceof でないかどうかを確認するには次のようにします。

+あるオブジェクトが特定のコンストラクターの `instanceof` でないことを検査するには、次のようにします。 -
if (!(mycar instanceof Car)) {
-  // Do something, like:
+```js
+if (!(mycar instanceof Car)) {
+  // 次のようなことをします。
   // mycar = new Car(mycar)
 }
-
- -

これは実際には次のものとは異なります。

- -
if (!mycar instanceof Car)
+``` -

これは常に false になります。(!mycar は instanceof の前に評価され、常に Car のインスタンスを確認したブール値になります)。

+これは実際には次のものとは異なります。 -

仕様

+```js +if (!mycar instanceof Car) +``` - - - - - - - - - -
仕様書
{{SpecName('ESDraft', '#sec-relational-operators', 'Relational Operators')}}
+これは常に `false` になります。（`!mycar` は `instanceof` の前に評価されるため、常に論理値が `Car` のインスタンスであるかどうかを検査しようとします。） -

ブラウザー実装状況

+## 仕様書 +{{Specifications}} +## ブラウザーの互換性 -

{{Compat("javascript.operators.instanceof")}}

+{{Compat}} -

関連情報

+## 関連情報 - +- [`typeof`](/ja/docs/Web/JavaScript/Reference/Operators/typeof) +- {{jsxref("Symbol.hasInstance")}} +- {{jsxref("Object.prototype.isPrototypeOf")}} -- cgit v1.2.3-54-g00ecf