recursal/MDN huggingface dataset:
handler.setPrototypeOf()
========================

**`handler.setPrototypeOf()`** メソッドは、オブジェクトの `[[SetPrototypeOf]]` 内部メソッドに対するトラップです。`Object.setPrototypeOf()` などの操作で使用されます。

試してみましょう
--------

構文
--


```js
new Proxy(target, {
  setPrototypeOf(target, prototype) {
  }
});
```

### 引数

次の引数は `setPrototypeOf()` メソッドに渡されます。 `this` はハンドラーにバインドされます。

`target`

ターゲットオブジェクトです。

`prototype`

オブジェクトの新しいプロトタイプ、または `null` です。

### 返値

`setPrototypeOf()` メソッドは `[[Prototype]]` の変更に成功したら `true` を返し、そうでない場合は `false` を返します。

解説
--

### 介入

このトラップは下記の操作に介入できます。

* `Object.setPrototypeOf()`
* `Reflect.setPrototypeOf()`

他にも、`[[SetPrototypeOf]]` 内部メソッドを呼び出すあらゆる操作に介入できます。

### 不変条件

以下の不変条件に違反している場合、プロキシーは `TypeError` を発生します。

* `target` が拡張可能でない場合、引数の `prototype` は `Object.getPrototypeOf(target)` と同じ値でなければなりません。
例
-

オブジェクトに新しいプロトタイプを設定することを禁止したい場合は、ハンドラーの `setPrototypeOf()` メソッドで `false` を返したり、例外を発生させたりするようにすることができます。

### アプローチ 1: false を返す

このアプローチでは、例外を発生させる変更操作は、それ自身で例外を生成する必要があります。

例えば、 `Object.setPrototypeOf()` は、それ自体が `TypeError` を発生させます。 `Reflect.setPrototypeOf()` のように、失敗しても通常は例外が発生しない操作で変更操作が行われた場合、例外は発生しません。


```js
const handlerReturnsFalse = {
  setPrototypeOf(target, newProto) {
    return false;
  },
};

const newProto = {},
  target = {};

const p1 = new Proxy(target, handlerReturnsFalse);
Object.setPrototypeOf(p1, newProto); // throws a TypeError
Reflect.setPrototypeOf(p1, newProto); // returns false
```

### アプローチ 2: 例外を発生

後者のアプローチでは、変更を試みるすべての操作で例外が発生します。このアプローチは、例外を発生しない操作でも失敗時に例外をは正させたい場合や、カスタムの例外値を発生させたい場合に最適です。


```js
const handlerThrows = {
  setPrototypeOf(target, newProto) {
    throw new Error("custom error");
  },
};

const newProto = {},
  target = {};

const p2 = new Proxy(target, handlerThrows);
Object.setPrototypeOf(p2, newProto); // throws new Error("custom error")
Reflect.setPrototypeOf(p2, newProto); // throws new Error("custom error")
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-object-internal-methods-and-internal-slots-setprototypeof-v |

ブラウザーの互換性
---------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

関連情報
----

* `Proxy`
* `Proxy()` コンストラクター
* `Object.setPrototypeOf()`
* `Reflect.setPrototypeOf()`
handler.has()
=============

**`handler.has()`** は、オブジェクトの `[[HasProperty]]` 内部メソッドに対するトラップです。`in` 演算子などの操作で使用されます。

試してみましょう
--------

構文
--


```js
new Proxy(target, {
  has(target, prop) {
  }
});
```

### 引数

次の引数は `has()` メソッドに渡されます。 `this` はハンドラーにバインドされます。

`target`

ターゲットオブジェクトです。

`prop`

存在を確認するプロパティ名です。

### 返値

`has` メソッドは論理値を返さなければなりません。

解説
--

### 介入

このトラップは下記の操作に介入できます。

* `in` 演算子: `foo in proxy`
* `with` チェック: `with(proxy) { (foo); }`
* `Reflect.has()`

他にも、`[[HasProperty]]` 内部メソッドを呼び出すあらゆる操作に介入できます。

### 不変条件

以下の不変条件に違反している場合、プロキシーは `TypeError` を発生します。

* プロパティがターゲットオブジェクトの設定不可の独自プロパティとして存在する場合、存在しないとして報告されてはいけません。
* プロパティがターゲットオブジェクトの独自プロパティとして存在し、そのターゲットオブジェクトが拡張不可の場合、存在しないとして報告されてはいけません。
例
-

### in 演算子のトラップ

次のコードでは `in` 演算子をトラップします。


```js
const p = new Proxy(
  {},
  {
    has(target, prop) {
      console.log(`called: ${prop}`);
      return true;
    },
  },
);

console.log("a" in p);
// "called: a"
// true
```


次のコードでは不変条件に違反します。


```js
const obj = { a: 10 };
Object.preventExtensions(obj);

const p = new Proxy(obj, {
  has(target, prop) {
    return false;
  },
});

"a" in p; // TypeError is thrown
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-object-internal-methods-and-internal-slots-hasproperty-p |

ブラウザーの互換性
---------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

関連情報
----

* `Proxy`
* `Proxy()` コンストラクター
* `in` 演算子
* `Reflect.has()`
handler.get()
=============

**`handler.get()`** は、オブジェクトの `[[Get]]` 内部メソッドに対するトラップです。プロパティアクセサーなどの操作で使用されます。

試してみましょう
--------

構文
--


```js
new Proxy(target, {
  get(target, property, receiver) {
  }
});
```

### 引数

次の引数が `get()` メソッドに渡されます。 `this` はハンドラーにバインドされます。

`target`

ターゲットオブジェクト

`property`

取得するプロパティの名称

`receiver`

プロキシー、またはプロキシーから継承するオブジェクトのどちらか

### 返値

`get()` メソッドはどんな値でも返すことができます。

解説
--

### 介入

このトラップは下記の操作に介入できます。

* プロパティアクセス: `proxy[foo]` と `proxy.bar`
* `Reflect.get()`

他にも、`[[Get]]` 内部メソッドを呼び出すあらゆる操作に介入できます。

### 不変条件

以下の不変条件に違反している場合、プロキシーは `TypeError` を発生します。

* ターゲットオブジェクトプロパティが書き込み不可、構成不可の自分自身のデータプロパティである場合、プロパティとして報告される値は、対応するターゲットオブジェクトプロパティの値と同じでなければなりません。
* 対応する対象オブジェクトのプロパティが、`[[Get]]` 属性として `undefined` を持つ、構成不可の自分自身のアクセサープロパティである場合、プロパティに対して報告される値は undefined でなければなりません。
例
-

### プロパティ値の取得のトラップ

次のコードではプロパティ値の取得をトラップします。


```js
const p = new Proxy(
  {},
  {
    get(target, property, receiver) {
      console.log(`called: ${property}`);
      return 10;
    },
  },
);

console.log(p.a);
// "called: a"
// 10
```


次のコードでは不変条件に違反します。


```js
const obj = {};
Object.defineProperty(obj, "a", {
  configurable: false,
  enumerable: false,
  value: 10,
  writable: false,
});

const p = new Proxy(obj, {
  get(target, property) {
    return 20;
  },
});

p.a; // TypeError is thrown
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-object-internal-methods-and-internal-slots-get-p-receiver |

ブラウザーの互換性
---------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

関連情報
----

* `Proxy`
* `Proxy()` コンストラクター
* `Reflect.get()`
handler.defineProperty()
========================

**`handler.defineProperty()`** は、オブジェクトの `[[DefineOwnProperty]]` 内部メソッドに対するトラップです。`Object.defineProperty()` などの操作で使用されます。

試してみましょう
--------

構文
--


```js
new Proxy(target, {
  defineProperty(target, property, descriptor) {
  }
});
```

### 引数

 次の引数が `defineProperty()` メソッドに渡されます。
 `this` はハンドラーにバインドされます。

`target`

ターゲットオブジェクトです。

`property`

説明を受け取るプロパティの名前または `Symbol` です。

`descriptor`

定義や変更されるプロパティに対するディスクリプターです。

### 返値

`defineProperty()` メソッドはプロパティが正しく定義されたかどうかを表す論理値を返す必要があります。

解説
--

### 介入

このトラップは下記の操作に介入できます。

* `Object.defineProperty()`, `Object.defineProperties()`
* `Reflect.defineProperty()`

他にも、`[[DefineOwnProperty]]` 内部メソッドを呼び出すあらゆる操作に介入できます。

### 不変条件

以下の不変条件に違反している場合、プロキシーは `TypeError` を発生します。

* ターゲットオブジェクトが拡張不可の場合、プロパティは追加できません。
* ターゲットオブジェクトの構成不可の独自のプロパティとして存在しない場合、プロパティは構成不可とみなされ、追加や変更ができません。
* ターゲットオブジェクトの対応する構成可能なプロパティが存在する場合、プロパティは構成不可にすることができません。
* 対応するターゲットオブジェクトのプロパティが存在する場合、`Object.defineProperty(target, prop, descriptor)` は例外をスローしません。
* strict モードでは、`defineProperty` ハンドラーから `false` が返ってきた場合、`TypeError` 例外をスローします。
例
-

### defineProperty のトラップ

次のコードは `Object.defineProperty()` をトラップします。


```js
const p = new Proxy(
  {},
  {
    defineProperty(target, prop, descriptor) {
      console.log(`called: ${prop}`);
      return true;
    },
  },
);

const desc = { configurable: true, enumerable: true, value: 10 };
Object.defineProperty(p, "a", desc); // "called: a"
```


`Object.defineProperty()` または `Reflect.defineProperty()` を呼び出した時、 `defineProperty()` トラップに渡されるディスクリプターには制約があります。下記のプロパティのみが使用可能で、標準ではないプロパティは無視されます。

* `enumerable`
* `configurable`
* `writable`
* `value`
* `get`
* `set`


```js
const p = new Proxy(
  {},
  {
    defineProperty(target, prop, descriptor) {
      console.log(descriptor);
      return Reflect.defineProperty(target, prop, descriptor);
    },
  },
);

Object.defineProperty(p, "name", {
  value: "proxy",
  type: "custom",
}); // { value: 'proxy' }
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-object-internal-methods-and-internal-slots-defineownproperty-p-desc |

ブラウザーの互換性
---------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

関連情報
----

* `Proxy`
* `Proxy()` コンストラクター
* `Object.defineProperty()`
* `Reflect.defineProperty()`
handler.set()
=============

**`handler.set()`** は、オブジェクトの `[[Set]]` 内部メソッドに対するトラップです。プロパティの値を設定することに対するトラップです。

試してみましょう
--------

構文
--


```js
new Proxy(target, {
  set(target, property, value, receiver) {
  }
});
```

### 引数

次の引数は `set()` メソッドに渡されます。`this` はハンドラーにバインドされます。

`target`

ターゲットオブジェクトです。

`property`

プロパティを設定する名前または `Symbol` です。

`value`

設定するプロパティの新しい値です。

`receiver`

割り当てがもともと行われていたオブジェクトです。これは通常、プロキシーそのものです。しかし、 `set()` ハンドラーは内部的にプロトタイプチェーンや様々な他の方法経由で呼び出されます。

例えば、スクリプト上に `obj.name = "jen"` があり、`obj` はプロキシーではなく、独自の `.name` プロパティを持っていません。しかし、プロトタイプチェーンでプロキシーを持っています。その場合、そのプロキシーの `set()` ハンドラーが呼ばれて、 `obj` はレシーバーとして渡されます。

### 返値

`set()` メソッドは論理値を返します。

* `true` を返すと割り当てが成功したことを示します。
* `set()` メソッドの返値が `false` で、厳格モードで割り当てが起こった場合、 `TypeError` が発生します。
解説
--

### 介入

このトラップは下記の操作に介入できます。

* プロパティへの代入: `proxy[foo] = bar` や `proxy.foo = bar`
* `Reflect.set()`

他にも、`[[Set]]` 内部メソッドを呼び出すあらゆる操作に介入できます。

### 不変条件

以下の不変条件に違反している場合、プロキシーで `TypeError` が発生します。

* 対応するターゲットオブジェクトのプロパティが書き込み不可かつ設定不可のデータプロパティの場合、プロパティの値と異なる値に変更することはできません。
* 対応するターゲットオブジェクトのプロパティが `[[Set]]` 属性として `undefined` を持つ設定不可のアクセスプロパティの場合、プロパティの値を設定することはできません。
* 厳格モードでは、`set()` ハンドラーから `false` を返す場合、 `TypeError` 例外が発生します。
例
-

### プロパティ値の設定のトラップ

次のコードではプロパティの値の設定をトラップします。


```js
const p = new Proxy(
  {},
  {
    set(target, prop, value, receiver) {
      target[prop] = value;
      console.log(`property set: ${prop} = ${value}`);
      return true;
    },
  },
);

console.log("a" in p); // false

p.a = 10; // "property set: a = 10"
console.log("a" in p); // true
console.log(p.a); // 10
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-object-internal-methods-and-internal-slots-set-p-v-receiver |

ブラウザーの互換性
---------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

関連情報
----

* `Proxy`
* `Proxy()` コンストラクター
* `Reflect.set()`
handler.isExtensible()
======================

**`handler.isExtensible()`** は、オブジェクトの `[[IsExtensible]]` 内部メソッドに対するトラップです。`Object.isExtensible()` などの操作で使用されます。

試してみましょう
--------

構文
--


```js
new Proxy(target, {
  isExtensible(target) {
  }
});
```

### 引数

 次の引数は `isExtensible()` メソッドに渡されます。
 `this` はハンドラーにバインドされます。

`target`

ターゲットオブジェクトです。

### 返値

`isExtensible` メソッドは論理値を返さなければなりません。

解説
--

### 介入

このトラップは下記の操作に介入できます。

* `Object.isExtensible()`
* `Reflect.isExtensible()`

他にも、`[[IsExtensible]]` 内部メソッドを呼び出すあらゆる操作に介入できます。

### 不変条件

以下の不変条件に違反している場合、プロキシーは `TypeError` を発生させます。

* `Object.isExtensible(proxy)` は `Object.isExtensible(target)` と同じ値を返さなければなりません。
例
-

### getOwnPropertyNames のトラップ

次のコードでは `Object.isExtensible()` をトラップします。


```js
const p = new Proxy(
  {},
  {
    isExtensible(target) {
      console.log("called");
      return true;
    },
  },
);

console.log(Object.isExtensible(p));
// "called"
// true
```


次のコードでは不変条件に違反します。


```js
const p = new Proxy(
  {},
  {
    isExtensible(target) {
      return false;
    },
  },
);

Object.isExtensible(p); // TypeError is thrown
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-object-internal-methods-and-internal-slots-isextensible |

ブラウザーの互換性
---------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

関連情報
----

* `Proxy`
* `Proxy()` コンストラクター
* `Object.isExtensible()`
* `Reflect.isExtensible()`
* `Reflect.preventExtensions()`
handler.ownKeys()
=================

**`handler.ownKeys()`** メソッドは、オブジェクトの `[[OwnPropertyKeys]]` 内部メソッドに対するトラップです。 `Object.keys()`, `Reflect.ownKeys()` などの操作で使用されます。

試してみましょう
--------

構文
--


```js
new Proxy(target, {
  ownKeys(target) {
  }
});
```

### 引数

次の引数は `ownKeys()` メソッドに渡されます。 `this` はハンドラーにバインドされます。

`target`

ターゲットオブジェクトです。

### 返値

`ownKeys()` メソッドは列挙可能オブジェクトを返さなければなりません。

解説
--

### 介入

このトラップは下記の操作に介入できます。

* `Object.getOwnPropertyNames()`
* `Object.getOwnPropertySymbols()`
* `Object.keys()`
* `Reflect.ownKeys()`

他にも、`[[OwnPropertyKeys]]` 内部メソッドを呼び出すあらゆる操作に介入できます。

### 不変条件

以下の不変条件に違反している場合、プロキシーは `TypeError` を発生します。

* `ownKeys()` の結果は配列である必要があります。
* 配列のそれぞれの要素の型は、`String` または `Symbol` のどちらかです。
* 結果のリストはターゲットオブジェクトのすべての非設定の独自プロパティのキーを含みます。
* ターゲットオブジェクトが拡張可能でないなら、結果リストはターゲットオブジェクトのすべての独自プロパティのキーを含まなければなりません。そして、他の値を含みません。
例
-

### getOwnPropertyNames のトラップ

次のコードでは `Object.getOwnPropertyNames()` をトラップします。


```js
const p = new Proxy(
  {},
  {
    ownKeys(target) {
      console.log("called");
      return ["a", "b", "c"];
    },
  },
);

console.log(Object.getOwnPropertyNames(p));
// "called"
// [ 'a', 'b', 'c' ]
```


次のコードでは不変条件に違反します。


```js
const obj = {};
Object.defineProperty(obj, "a", {
  configurable: false,
  enumerable: true,
  value: 10,
});

const p = new Proxy(obj, {
  ownKeys(target) {
    return [123, 12.5, true, false, undefined, null, {}, []];
  },
});

console.log(Object.getOwnPropertyNames(p));

// TypeError: proxy [[OwnPropertyKeys]] must return an array
// with only string and symbol elements
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-object-internal-methods-and-internal-slots-ownpropertykeys |

ブラウザーの互換性
---------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

関連情報
----

* `Proxy`
* `Proxy()` コンストラクター
* `Object.getOwnPropertyNames()`
* `Reflect.ownKeys()`
handler.getOwnPropertyDescriptor()
==================================

**`handler.getOwnPropertyDescriptor()`** は、オブジェクトの `[[GetOwnProperty]]` 内部メソッドに対するトラップです。`Object.getOwnPropertyDescriptor()` などの操作で使用されます。

試してみましょう
--------

構文
--


```js
new Proxy(target, {
  getOwnPropertyDescriptor(target, prop) {
  }
});
```

### 引数

次の引数は `getOwnPropertyDescriptor()` メソッドに渡されます。 `this` はハンドラーにバインドされます。

`target`

ターゲットオブジェクトです。

`prop`

ディスクリプタを取得されるプロパティ名です。

### 返値

`getOwnPropertyDescriptor` メソッドはオブジェクト、または `undefined` を返さなければなりません。

解説
--

### 介入

このトラップは下記の操作に介入できます。

* `Object.getOwnPropertyDescriptor()`
* `Reflect.getOwnPropertyDescriptor()`

他にも、`[[GetOwnProperty]]` 内部メソッドを呼び出すあらゆる操作に介入できます。

### 不変条件

以下の不変条件に違反している場合、プロキシーは `TypeError` を発生します。

* `getOwnPropertyDescriptor()` はオブジェクトか、または `undefined` を返さなければなりません。
* プロパティがターゲットオブジェクトの設定不可な独自のプロパティとして存在する場合、存在しないとして報告されてはいけません。
* プロパティがターゲットオブジェクトの独自のプロパティとして存在し、そのターゲットオブジェクトが拡張不可の場合、存在しないとして報告されてはいけません。
* プロパティがターゲットオブジェクトの独自のプロパティとして存在せず、そのターゲットオブジェクトが拡張不可の場合、存在するとして報告されてはいけません。
* プロパティがターゲットオブジェクトの独自のプロパティとして存在しないか、ターゲットオブジェクトの設定可能な独自のプロパティとして存在している場合、設定不可であるとして報告されてはいけません。
* `Object.getOwnPropertyDescriptor(target)` の結果を `Object.defineProperty()` に使用した時に、ターゲットオブジェクトに適用でき、例外を発生させません。
例
-

### getOwnPropertyDescriptor のトラップ

次のコードでは `Object.getOwnPropertyDescriptor()` をトラップします。


```js
const p = new Proxy(
  { a: 20 },
  {
    getOwnPropertyDescriptor(target, prop) {
      console.log(`called: ${prop}`);
      return { configurable: true, enumerable: true, value: 10 };
    },
  },
);

console.log(Object.getOwnPropertyDescriptor(p, "a").value);
// "called: a"
// 10
```


次のコードでは不変条件に違反します。


```js
const obj = { a: 10 };
Object.preventExtensions(obj);
const p = new Proxy(obj, {
  getOwnPropertyDescriptor(target, prop) {
    return undefined;
  },
});

Object.getOwnPropertyDescriptor(p, "a"); // TypeError is thrown
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-object-internal-methods-and-internal-slots-getownproperty-p |

ブラウザーの互換性
---------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

関連情報
----

* `Proxy`
* `Proxy()` コンストラクター
* `Object.getOwnPropertyDescriptor()`
* `Reflect.getOwnPropertyDescriptor()`
handler.preventExtensions()
===========================

**`handler.preventExtensions()`** はオブジェクトの `[[PreventExtensions]]` 内部メソッドに対するトラップです。 `Object.preventExtensions()` のような操作で使用されます。

試してみましょう
--------

構文
--


```js
new Proxy(target, {
  preventExtensions(target) {
  }
});
```

### 引数

次の引数は `preventExtensions()` メソッドに渡されます。 `this` はハンドラーにバインドされます。

`target`

ターゲットオブジェクトです。

### 返値

`preventExtensions()` メソッドは論理値を返さなければなりません。

解説
--

### 介入

このトラップは下記の操作に介入できます。

* `Object.preventExtensions()`
* `Reflect.preventExtensions()`
* `Object.seal()`
* `Object.freeze()`

他にも、`[[PreventExtensions]]` 内部メソッドを呼び出すあらゆる操作に介入できます。

### 不変条件

以下の不変条件に違反している場合、プロキシーは `TypeError` を発生します。

* `Object.preventExtensions(proxy)` は、 `Object.isExtensible(proxy)` が `false` の場合のみ `true` を返します。
例
-

### preventExtensions のトラップ

次のコードでは `Object.preventExtensions()` をトラップします。


```js
const p = new Proxy(
  {},
  {
    preventExtensions(target) {
      console.log("called");
      Object.preventExtensions(target);
      return true;
    },
  },
);

console.log(Object.preventExtensions(p));
// "called"
// false
```


以下のコードは不変条件に違反しています。


```js
const p = new Proxy(
  {},
  {
    preventExtensions(target) {
      return true;
    },
  },
);

Object.preventExtensions(p); // TypeError is thrown
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-object-internal-methods-and-internal-slots-preventextensions |

ブラウザーの互換性
---------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

関連情報
----

* `Proxy`
* `Proxy()` コンストラクター
* `Object.preventExtensions()`
* `Reflect.preventExtensions()`
handler.deleteProperty()
========================

**`handler.deleteProperty()`** メソッドは、オブジェクトの `[[Get]]` 内部メソッドに対するトラップです。`delete` などの操作で使用されます。

試してみましょう
--------

構文
--


```js
new Proxy(target, {
  deleteProperty(target, property) {
  }
});
```

### 引数

 次の引数が `deleteProperty` メソッドに渡されます。
 `this` はハンドラーにバインドされます。

`target`

ターゲットオブジェクト

`property`

削除するプロパティの名前または `Symbol`

### 返値

`deleteProperty()` メソッドはプロパティが正しく削除されたかどうか示す論理値を返さなければなりません。

解説
--

### 介入

このトラップは下記の操作に介入できます。

* `delete` 演算子: `delete proxy[foo]` や `delete proxy.foo`
* `Reflect.deleteProperty()`

他にも、`[[Delete]]` 内部メソッドを呼び出すあらゆる操作に介入できます。

### 不変条件

以下の不変条件に違反している場合、プロキシーは `TypeError` を発生します。

* ターゲットオブジェクトの非設定独自プロパティとして存在する場合、プロパティは削除されません。
例
-

### プロパティ値の取得のトラップ

次のコードは `delete` 操作をトラップします。


```js
const p = new Proxy(
  {},
  {
    deleteProperty(target, prop) {
      if (!(prop in target)) {
        console.log(`property not found: ${prop}`);
        return false;
      }
      delete target[prop];
      console.log(`property removed: ${prop}`);
      return true;
    },
  },
);

p.a = 10;
console.log("a" in p); // true

const result1 = delete p.a; // "property removed: a"
console.log(result1); // true
console.log("a" in p); // false

const result2 = delete p.a; // "property not found: a"
console.log(result2); // false
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-object-internal-methods-and-internal-slots-delete-p |

ブラウザーの互換性
---------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

関連情報
----

* `Proxy`
* `Proxy()` コンストラクター
* `delete` operator
* `Reflect.deleteProperty()`
handler.getPrototypeOf()
========================

**`handler.getPrototypeOf()`** メソッドは、オブジェクトの `[[GetPrototypeOf]]` 内部メソッドに対するトラップです。`Object.getPrototypeOf()` などの操作で使用されます。

試してみましょう
--------

構文
--


```js
new Proxy(obj, {
  getPrototypeOf(target) {
    // …
  }
});
```

### 引数

 次の引数は `getPrototypeOf()` メソッドに渡されます。
 `this` はハンドラーにバインドされます。

`target`

ターゲットオブジェクトです。

### 返値

`getPrototypeOf()` メソッドはオブジェクト、または `null` を返さなければなりません。

解説
--

### 介入

このトラップは下記の操作に介入できます。

* `Object.getPrototypeOf()`
* `Reflect.getPrototypeOf()`
* `__proto__`
* `Object.prototype.isPrototypeOf()`
* `instanceof`

他にも、`[[GetPrototypeOf]]` 内部メソッドを呼び出すあらゆる操作に介入できます。

### 不変条件

以下の不変条件に違反している場合、プロキシーは `TypeError` を発生します。

* `getPrototypeOf` メソッドはオブジェクト、または `null` を返さなければなりません。
* `target`が拡張不可の場合、 `Object.getPrototypeOf(proxy)` メソッドは `Object.getPrototypeOf(target)` と同じ値を返さなければなりません。
例
-

### 基本的な使い方


```js
const obj = {};
const proto = {};
const handler = {
  getPrototypeOf(target) {
    console.log(target === obj); // true
    console.log(this === handler); // true
    return proto;
  },
};

const p = new Proxy(obj, handler);
console.log(Object.getPrototypeOf(p) === proto); // true
```

### getPrototypeOf トラップが発生する５つの方法


```js
const obj = {};
const p = new Proxy(obj, {
  getPrototypeOf(target) {
    return Array.prototype;
  },
});
console.log(
  Object.getPrototypeOf(p) === Array.prototype, // true
  Reflect.getPrototypeOf(p) === Array.prototype, // true
  p.__proto__ === Array.prototype, // true
  Array.prototype.isPrototypeOf(p), // true
  p instanceof Array, // true
);
```

### 2 種類の例外


```js
const obj = {};
const p = new Proxy(obj, {
  getPrototypeOf(target) {
    return "foo";
  },
});
Object.getPrototypeOf(p); // TypeError: "foo" is not an object or null

const obj = Object.preventExtensions({});
const p = new Proxy(obj, {
  getPrototypeOf(target) {
    return {};
  },
});
Object.getPrototypeOf(p); // TypeError: expected same prototype value
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-object-internal-methods-and-internal-slots-getprototypeof |

ブラウザーの互換性
---------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

関連情報
----

* `Proxy`
* `Proxy()` コンストラクター
* `Object.getPrototypeOf()`
* `Reflect.getPrototypeOf()`
handler.construct()
===================

**`handler.construct()`** メソッドは、オブジェクトの `[[Construct]]` 内部メソッドに対するトラップです。`new` 演算子などの操作で使用されます。結果としてのプロキシーオブジェクトが new 演算子を使用できるようにするためには、プロキシを初期化するために使用されるターゲット自体が有効なコンストラクターである必要があります。

試してみましょう
--------

構文
--


```js
new Proxy(target, {
  construct(target, argumentsList, newTarget) {
  }
});
```

### 引数

次の引数が `construct()` メソッドに渡されます。 `this` はハンドラーにバインドされます。

`target`

ターゲットオブジェクト

`argumentsList`

コンストラクタに対する引数のリスト

`newTarget`

上記の `p` に呼び出された元のコンストラクターです。

### 返値

`construct` メソッドはオブジェクトを返す必要があります。

解説
--

### 介入

このトラップは下記の操作に介入できます。

* The `new` 演算子: `new myFunction(...args)`
* `Reflect.construct()`

他にも、`[[Construct]]` 内部メソッドを呼び出すあらゆる操作に介入できます。

### 不変条件

以下の不変条件に違反している場合、呼び出されるとトラップで `TypeError` が発生します。

* 結果が `Object` でならなければならない。
例
-

### new 演算子のトラップ

次のコードでは `new` 操作をトラップします。


```js
const p = new Proxy(function () {}, {
  construct(target, argumentsList, newTarget) {
    console.log(`called: ${argumentsList}`);
    return { value: argumentsList[0] \* 10 };
  },
});

console.log(new p(1).value); // "called: 1"
// 10
```


次のコードでは不変条件に違反します。


```js
const p = new Proxy(function () {}, {
  construct(target, argumentsList, newTarget) {
    return 1;
  },
});

new p(); // TypeError is thrown
```


次のコードはプロキシーを正しく初期化していません。プロキシーの `target` の初期化は、それ自身が `new` 演算子に有効なコンストラクターでなければなりません。


```js
const p = new Proxy(
  {},
  {
    construct(target, argumentsList, newTarget) {
      return {};
    },
  },
);

new p(); // TypeError is thrown, "p" is not a constructor
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-object-internal-methods-and-internal-slots-construct-argumentslist-newtarget |

ブラウザーの互換性
---------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

関連情報
----

* `Proxy`
* `Proxy()` コンストラクター
* `new` 演算子
* `Reflect.construct()`
handler.apply()
===============

**`handler.apply()`** メソッドは、オブジェクトの `[[Call]]` 内部メソッドに対するトラップです。関数呼び出しなどの操作で使用されます。

試してみましょう
--------

構文
--


```js
new Proxy(target, {
  apply(target, thisArg, argumentsList) {
  }
});
```

### 引数

次の引数が `apply()` メソッドに渡されます。 `this` はハンドラーにバインドされます。

`target`

ターゲットオブジェクト

`thisArg`

この呼び出しに対する `this` 引数

`argumentsList`

この呼び出しに対する引数リスト

### 返値

`apply()` メソッドはどんな値でも返すことができます。

解説
--

### 介入

このトラップは下記の操作に介入できます。

* 関数呼び出し: `proxy(...args)`
* `Function.prototype.apply()` and `Function.prototype.call()`
* `Reflect.apply()`

他にも、`[[Call]]` 内部メソッドを呼び出すあらゆる操作に介入できます。

### 不変条件

以下の不変条件に違反している場合、トラップが呼び出されると `TypeError` が発生します。

* `target` は呼び出し可能である必要があります。つまり関数オブジェクトでなければなりません。
例
-

### 関数呼び出しのトラップ

次のコードでは、関数呼び出しをトラップします。


```js
const p = new Proxy(function () {}, {
  apply(target, thisArg, argumentsList) {
    console.log(`called: ${argumentsList}`);
    return argumentsList[0] + argumentsList[1] + argumentsList[2];
  },
});

console.log(p(1, 2, 3)); // "called: 1,2,3"
// 6
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-object-internal-methods-and-internal-slots-call-thisargument-argumentslist |

ブラウザーの互換性
---------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

関連情報
----

* `Proxy`
* `Proxy()` コンストラクター
* `Function.prototype.apply()`
* `Function.prototype.call()`
* `Reflect.apply()`