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

静的な **`Reflect.setPrototypeOf()`** メソッドは、返値を除いて、 `Object.setPrototypeOf()` と同じメソッドです。これは指定されたオブジェクトのプロトタイプ (つまり、内部の `[[Prototype]]` プロパティ) にほかのオブジェクト、または `null` を設定し、操作が成功したなら `true` を、そうでないなら `false` を返します。

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

構文
--
```

Reflect.setPrototypeOf(target, prototype)
```

### 引数

`target`

プロトタイプを設定する対象のオブジェクトです。

`prototype`

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

### 返値

プロトタイプが正常に設定されたかどうかを示す `Boolean` 値です。

### 例外

`TypeError`: `target` が `Object` ではない場合、または `prototype` がオブジェクトでも `null` でもない場合。

解説
--

`Reflect.setPrototypeOf` メソッドは、指定されたオブジェクトのプロトタイプ (つまり、内部の `[[Prototype]]` プロパティ) を変更します。

例
-

### Reflect.setPrototypeOf() の使用


```js
Reflect.setPrototypeOf({}, Object.prototype); // true

// オブジェクトの [[Prototype]] は null に変更できる。
Reflect.setPrototypeOf({}, null); // true

// 対象が拡張できない場合、false を返す。
Reflect.setPrototypeOf(Object.freeze({}), null); // false

// プロトタイプチェーンが循環する場合、false を返す。
let target = {};
let proto = Object.create(target);
Reflect.setPrototypeOf(target, proto); // false
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.setprototypeof |

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

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

関連情報
----

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

静的な **`Reflect.get()`** メソッドは、オブジェクト (`target[propertyKey]`) からプロパティを関数として取得するように動作します。

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

構文
--


```js
Reflect.get(target, propertyKey[, receiver])
```

### 引数

`target`

プロパティを取得する対象のオブジェクト。

`propertyKey`

設定するプロパティ名。

`receiver` 省略可

ゲッターがあった場合、 `target` への呼び出しで使用する `this` の値を提供します。 `Proxy` とともに使用すると、 `target` から継承しているオブジェクトにすることができます。

### 返値

プロパティの値です。

### 例外

`target` が `Object` でなかった場合、 `TypeError` が発生します。

解説
--

`Reflect.get` メソッドはオブジェクトのプロパティを取得します。機能としてはプロパティアクセサー構文と似ています。

例
-

### `Reflect.get()` の使用


```js
// オブジェクト
let obj = { x: 1, y: 2 };
Reflect.get(obj, "x"); // 1

// 配列
Reflect.get(["zero", "one"], 1); // "one"

// Proxy with a get handler
let x = { p: 1 };

let obj = new Proxy(x, {
  get(t, k, r) {
    return k + "bar";
  },
});
Reflect.get(obj, "foo"); // "foobar"

//Proxy with get handler and receiver
let x = { p: 1, foo: 2 };
let y = { foo: 3 };

let obj = new Proxy(x, {
  get(t, prop, receiver) {
    return receiver[prop] + "bar";
  },
});
Reflect.get(obj, "foo", y); // "3bar"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.get |

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

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

関連情報
----

* `Reflect`
* プロパティアクセサー
Reflect.has()
=============

静的な **`Reflect.has()`** メソッドは、機能としては `in` 演算子のように動作します。

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

構文
--
```

Reflect.has(target, propertyKey)
```

### 引数

`target`

プロパティを探す対象のオブジェクト。

`propertyKey`

チェックするプロパティ名。

### 返値

対象がプロパティを持つかどうかを示す `Boolean` 値。

### 例外

`target` が `Object` でなかった場合、 `TypeError` が発生します。

解説
--

`Reflect.has` メソッドは、オブジェクトプロパティがあるかをチェックします。機能としては `in` 演算子のように動作します。

例
-

### Reflect.has() の使用


```js
Reflect.has({ x: 0 }, "x"); // true
Reflect.has({ x: 0 }, "y"); // false

// プロトタイプチェーンのプロパティがあるため、true が返る
Reflect.has({ x: 0 }, "toString");

// Proxy with .has() handler method
obj = new Proxy(
  {},
  {
    has(t, k) {
      return k.startsWith("door");
    },
  },
);
Reflect.has(obj, "doorbell"); // true
Reflect.has(obj, "dormitory"); // false
```


`Reflect.has` は継承されたプロパティについて `true` を返し、これは `in` 演算子と同様です。


```js
const a = { foo: 123 };
const b = { \_\_proto\_\_: a };
const c = { \_\_proto\_\_: b };
// The prototype chain is: c -> b -> a
Reflect.has(c, "foo"); // true
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.has |

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

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

関連情報
----

* `Reflect`
* `in` 演算子
Reflect.apply()
===============

静的な **`Reflect.apply()`** メソッドは、指定された引数とともに対象となる関数を呼び出します。

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

構文
--
```

Reflect.apply(target, thisArgument, argumentsList)
```

### 引数

`target`

呼び出し対象の関数。

`thisArgument`

`target` の呼び出す際の `this` 値を提供する。

`argumentsList`

`target` と一緒に呼び出す引数を指定する配列風オブジェクト。

### 返値

指定された `target` 値と引数の条件で対象の関数を呼び出したときの結果です。

### 例外

`TypeError`: `target` が呼び出せない場合。

解説
--

ES5 では、ふつう `Function.prototype.apply()` メソッドを使用することで、指定された `this` の値と `arguments` で配列 (または 配列風オブジェクト) により引数を指定することで、関数を呼び出すことができます。


```js
Function.prototype.apply.call(Math.floor, undefined, [1.75]);
```


`Reflect.apply()` を使うと、それほど冗長ではなく理解しやすくなります。

例
-

### Reflect.apply() の使用


```js
Reflect.apply(Math.floor, undefined, [1.75]);
// 1;

Reflect.apply(String.fromCharCode, undefined, [104, 101, 108, 108, 111]);
// "hello"

Reflect.apply(RegExp.prototype.exec, /ab/, ["confabulation"]).index;
// 4

Reflect.apply("".charAt, "ponies", [3]);
// "i"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.apply |

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

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

関連情報
----

* `Reflect`
* `Function.prototype.apply()`
Reflect.defineProperty()
========================

静的な **`Reflect.defineProperty()`** メソッドは、`Object.defineProperty()` と似ていますが、 `Boolean` を返します。

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

構文
--
```

Reflect.defineProperty(target, propertyKey, attributes)
```

### 引数

`target`

プロパティを定義する対象のオブジェクトです。

`propertyKey`

定義または修正をするプロパティ名です。

`attributes`

定義または修正されているプロパティのための属性です。

### 返値

プロパティの定義に成功したかどうかを示す `Boolean` です。

### 例外

`TypeError`: `target` が `Object` ではなかった場合。

解説
--

`Reflect.defineProperty` メソッドは、オブジェクトのプロパティの正確な追加や修正を行います。詳細は、類似メソッドの `Object.defineProperty` を参照してください。

**メモ:** `Object.defineProperty` はプロパティの定義が成功しなかった場合、オブジェクトを返すか `TypeError` を発生させます。しかし、`Reflect.defineProperty` は単純に、プロパティの定義が成功したかどうかを示す `Boolean` を返します。

例
-

### Reflect.defineProperty() の使用


```js
let obj = {};
Reflect.defineProperty(obj, "x", { value: 7 }); // true
obj.x; // 7
```

### プロパティ定義が成功したかチェックする

成功してオブジェクトを返すか、失敗して `TypeError` をスローする `Object.defineProperty` を使う場合、プロパティの定義中に発生する何らかの例外をキャッチするには、`try...catch` ブロックを使用します。

`Reflect.defineProperty` は真偽値の成功ステータスを返すので、`if...else` ブロックを使用することができます。


```js
if (Reflect.defineProperty(target, property, attributes)) {
  // success
} else {
  // failure
}
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.defineproperty |

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

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

関連情報
----

* `Reflect`
* `Object.defineProperty()`
Reflect.construct()
===================

静的な **`Reflect.construct()`** メソッドは `new` 演算子のように、ただし関数として動作します。これは `new target(...args)` の呼び出しと同等です。このメソッドはオプションを追加することで、別なプロトタイプを指定することができます。

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

構文
--


```js
Reflect.construct(target, argumentsList);
Reflect.construct(target, argumentsList, newTarget);
```

### 引数

`target`

呼び出し対象の関数。

`argumentsList`

配列風オブジェクトで、 `target` の呼び出しの引数を指定する。

`newTarget` 省略可

プロトタイプを使用するコンストラクター。 `new.target` も参照してください。 `newTarget` が存在しない場合は、既定値は `target` になります。

### 返値

`target` (または、もしあれば `newTarget`) の新しいインスタンスで、 `target` に `argumentsList` を渡してコンストラクターとして呼び出すことで初期化します。

### 例外

`TypeError`: `target` または `newTarget` がコンストラクターではない場合。

解説
--

`Reflect.construct()` によって、可変長引数を指定してコンストラクターを呼び出すことができます。 (これはスプレッド構文と`new` 演算子を組み合わせて使用することでも可能です。)


```js
let obj = new Foo(...args);
let obj = Reflect.construct(Foo, args);
```

### `Reflect.construct()` と `Object.create()`

`Reflect` が導入される前は、オブジェクトを構築するのにコンストラクターとプロトタイプの任意の組み合わせで `Object.create()` を使用して構築することができました。


```js
function OneClass() {
  this.name = "one";
}

function OtherClass() {
  this.name = "other";
}

// Calling this:
let obj1 = Reflect.construct(OneClass, args, OtherClass);

// ...has the same result as this:
let obj2 = Object.create(OtherClass.prototype);
OneClass.apply(obj2, args);

console.log(obj1.name); // 'one'
console.log(obj2.name); // 'one'

console.log(obj1 instanceof OneClass); // false
console.log(obj2 instanceof OneClass); // false

console.log(obj1 instanceof OtherClass); // true
console.log(obj2 instanceof OtherClass); // true

//Another example to demonstrate below:

function func1(a, b, c, d) {
  console.log(arguments[3]);
}

function func2(d, e, f, g) {
  console.log(arguments[3]);
}

let obj1 = Reflect.construct(func1, ["I", "Love", "my", "India"]);
obj1;
```


この 2 つの手法の最終結果は同じですが、その過程に重要な違いがあります。 `Object.create()` と `Function.prototype.apply()` を使用する場合、 `new.target` 演算子はコンストラクター内で `undefined` を返します。これは、 `new` 演算子を用いないためです。

一方、 `Reflect.construct()` を呼び出す場合は、 `new.target` 演算子は、提供されていれば `newTarget` を指し、そうでなければ `target` を指します。


```js
function OneClass() {
  console.log("OneClass");
  console.log(new.target);
}
function OtherClass() {
  console.log("OtherClass");
  console.log(new.target);
}

let obj1 = Reflect.construct(OneClass, args);
// Output:
// OneClass
// function OneClass { ... }

let obj2 = Reflect.construct(OneClass, args, OtherClass);
// Output:
// OneClass
// function OtherClass { ... }

let obj3 = Object.create(OtherClass.prototype);
OneClass.apply(obj3, args);
// Output:
// OneClass
// undefined
```

例
-

### `Reflect.construct()` の使用


```js
let d = Reflect.construct(Date, [1776, 6, 4]);
d instanceof Date; // true
d.getFullYear(); // 1776
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.construct |

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

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

関連情報
----

* `Reflect.construct` のポリフィルが `core-js` にあります
* `Reflect`
* `new`
* `new.target`
Reflect.getPrototypeOf()
========================

静的な **`Reflect.getPrototypeOf()`** メソッドは、`Object.getPrototypeOf()` とほぼ同じメソッドです。これは指定したオブジェクトのプロトタイプ (つまり、内部の `[[Prototype]]` プロパティの値) を返します。

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

構文
--
```

Reflect.getPrototypeOf(target)
```

### 引数

`target`

プロトタイプを取得する対象のオブジェクトです。

### 返値

与えられたオブジェクトのプロトタイプです。継承されたプロパティがない場合、`null` を返します。

### 例外

`target` が `Object` でない場合に `TypeError` がスローされます。

解説
--

`Reflect.getPrototypeOf` メソッドは、指定したオブジェクトのプロトタイプ (つまり、内部の `[[Prototype]]` プロパティの値) を返します。

例
-

### Reflect.getPrototypeOf() の使用


```js
Reflect.getPrototypeOf({}); // Object.prototype
Reflect.getPrototypeOf(Object.prototype); // null
Reflect.getPrototypeOf(Object.create(null)); // null
```

### Object.getPrototypeOf() との比較


```js
// Object の結果は同じです
Object.getPrototypeOf({}); // Object.prototype
Reflect.getPrototypeOf({}); // Object.prototype

// ES5 上では非Objectの結果は両方とも例外です
Object.getPrototypeOf("foo"); // Throws TypeError
Reflect.getPrototypeOf("foo"); // Throws TypeError

// ES2015 上では Reflect のみ例外で、Object は 非Object を Object として扱います
Object.getPrototypeOf("foo"); // String.prototype
Reflect.getPrototypeOf("foo"); // Throws TypeError

// To mimic the Object ES2015 behavior you need to coerce
Reflect.getPrototypeOf(Object("foo")); // String.prototype
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.getprototypeof |

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

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

関連情報
----

* `Reflect`
* `Object.getPrototypeOf()`
Reflect.deleteProperty()
========================

静的な **`Reflect.defineProperty()`** メソッドは、`Object.defineProperty()` と似ていますが、 `Boolean` を返します。

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

構文
--
```

Reflect.defineProperty(target, propertyKey, attributes)
```

### 引数

`target`

プロパティを定義する対象のオブジェクトです。

`propertyKey`

定義または修正をするプロパティ名です。

`attributes`

定義または修正されているプロパティのための属性です。

### 返値

プロパティの定義に成功したかどうかを示す `Boolean` です。

### 例外

`TypeError`: `target` が `Object` ではなかった場合。

解説
--

`Reflect.defineProperty` メソッドは、オブジェクトのプロパティの正確な追加や修正を行います。詳細は、類似メソッドの `Object.defineProperty` を参照してください。

**メモ:** `Object.defineProperty` はプロパティの定義が成功しなかった場合、オブジェクトを返すか `TypeError` を発生させます。しかし、`Reflect.defineProperty` は単純に、プロパティの定義が成功したかどうかを示す `Boolean` を返します。

例
-

### Reflect.defineProperty() の使用


```js
let obj = {};
Reflect.defineProperty(obj, "x", { value: 7 }); // true
obj.x; // 7
```

### プロパティ定義が成功したかチェックする

成功してオブジェクトを返すか、失敗して `TypeError` をスローする `Object.defineProperty` を使う場合、プロパティの定義中に発生する何らかの例外をキャッチするには、`try...catch` ブロックを使用します。

`Reflect.defineProperty` は真偽値の成功ステータスを返すので、`if...else` ブロックを使用することができます。


```js
if (Reflect.defineProperty(target, property, attributes)) {
  // success
} else {
  // failure
}
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.deleteproperty |

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

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

関連情報
----

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

**`BigUint64Array()`** は型付き配列のコンストラクターで、新しい `BigUint64Array` オブジェクト、すなわち 64 ビット符号なし整数の配列をプラットフォームのバイトオーダーで生成します。バイトオーダーを制御する必要がある場合は、代わりに `DataView` を使用してください。中身は `0n` で初期化されます。生成後は、オブジェクトのメソッドや、標準の配列の添字構文 (すなわち角括弧表記) を用いて配列の要素を参照することができます。

構文
--
```

new BigUint64Array();
new BigUint64Array(length);
new BigUint64Array(typedArray);
new BigUint64Array(object);
new BigUint64Array(buffer [, byteOffset [, length]]);
```

### 引数

`length`

`length` 引数付きで呼び出された場合、 `length` を *`BYTES_PER_ELEMENT` バイトで掛けた大きさ*で、内部の配列バッファーがメモリ内に生成され、内容がゼロになります。

`typedArray`

`typedArray` 引数は任意の型付き配列 (`Int32Array` など) で、 `typedArray` を付けて呼び出された場合、その内容が新しい型付き配列に複写されます。 `typedArray` に含まれるそれぞれの値は、新しい配列にコピーされる前に、このコンストラクターに対応する型に変換されます。新しい型付き配列の長さは、 `typedArray` 引数の長さと同じになります。

`object`

`object` 引数付きで呼び出された場合、新しい型付き配列は `TypedArray.from()` メソッドのようにして生成されます。

`buffer`, `byteOffset`, `length`

`buffer` 引数と、任意で `byteOffset` および `length` 引数をつけて呼び出された場合、新しい型付き配列のビューが作成され、そのビューが指定された `ArrayBuffer` となります。 `byteOffset` および `length` 引数は、型付き配列のビューで公開するメモリの範囲を指定します。両方が省略された場合は、 `buffer` 全体がビューとなり、 `length` のみが省略された場合は、 `buffer` の残りがビューとなります。

例
-

### BigUint64Array を生成するための様々な方法


```js
// From a length
var biguint64 = new BigUint64Array(2);
biguint64[0] = 42n;
console.log(biguint64[0]); // 42n
console.log(biguint64.length); // 2
console.log(biguint64.BYTES\_PER\_ELEMENT); // 8

// From an array
var arr = new BigUint64Array([21n, 31n]);
console.log(arr[1]); // 31n

// From another TypedArray
var x = new BigUint64Array([21n, 31n]);
var y = new BigUint64Array(x);
console.log(y[0]); // 21n

// From an ArrayBuffer
var buffer = new ArrayBuffer(32);
var z = new BigUint64Array(buffer, 0, 4);

// From an iterable
var iterable = (function\* () {
  yield\* [1n, 2n, 3n];
})();
var biguint64 = new BigUint64Array(iterable);
// BigUint64Array[1n, 2n, 3n]
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-typedarray-constructors |

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

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

関連情報
----

* JavaScript typed arrays
* `BigInt64Array`
* `DataView`
Generator.prototype.return()
============================

**`return()`** メソッドは、指定された値を返してジェネレーターを終了します。

構文
--
```

gen.return(value)
```

### 引数

`value`

返却する値です。

### 返値

この関数に引数として与えられている値を返します。

例
-

### return() の使用

次の例では簡単なジェネレーターと `return` メソッドを示します。


```js
function\* gen() {
  yield 1;
  yield 2;
  yield 3;
}

const g = gen();

g.next(); // { value: 1, done: false }
g.return("foo"); // { value: "foo", done: true }
g.next(); // { value: undefined, done: true }
```


`return(value)` がすでに "完了" の状態のジェネレーターで呼び出されると、ジェネレーターは "完了" の状態のままになります。

引数が提供されなかった場合、返却されるオブジェクトの `value` プロパティは `.next()` の場合と同じになります。引数が提供された場合は、返却されるオブジェクトの `value` プロパティの値に設定されます。


```js
function\* gen() {
  yield 1;
  yield 2;
  yield 3;
}

const g = gen();
g.next(); // { value: 1, done: false }
g.next(); // { value: 2, done: false }
g.next(); // { value: 3, done: false }
g.next(); // { value: undefined, done: true }
g.return(); // { value: undefined, done: true }
g.return(1); // { value: 1, done: true }
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-generator.prototype.return |

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

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

関連情報
----

* `function*`
Generator.prototype.next()
==========================

**`next()`** メソッドは、2 つのプロパティ `done` と `value` を持つオブジェクトを返します。 `next` メソッドに引数を提供して、ジェネレーターへ値を送ることもできます。

構文
--


```js
generatorObject.next(value)
```

### 引数

`value`

ジェネレーターへ送る値です。

この値は `yield` 式の結果として代入されます。例えば `variable = yield expression` の場合、 `.next()` 関数に渡された値は `variable` に代入されます。

### 返値

以下の 2 つのプロパティを持った `Object` です。

`done` (boolean)

イテレーターが反復処理の末尾を過ぎている場合、値は `true` になります。この場合、 `value` はオプションでそのイテレーターの *返値* を指定します。

イテレーターが反復処理の次の値を生成することができた場合、値は `false` になります。これは `done` プロパティを指定しない場合も同等です。

`value`

イテレーターが yield または return した、何らかの JavaScript の値です。

例
-

### next() の使用

次の例では、 `next` メソッドが返す簡単なジェネレーターとオブジェクトを示します。


```js
function\* gen() {
  yield 1;
  yield 2;
  yield 3;
}

const g = gen(); // "Generator { }"
g.next(); // "Object { value: 1, done: false }"
g.next(); // "Object { value: 2, done: false }"
g.next(); // "Object { value: 3, done: false }"
g.next(); // "Object { value: undefined, done: true }"
```

### リストでの next() の使用

この例では、 `getPage` はリストを受け取り `pageSize` 件ごとにページ分割します。それぞれの `next` 呼び出しは個々のページを返します。


```js
function\* getPage(list, pageSize = 1) {
  for (let index = 0; index < list.length; index += pageSize) {
    yield list.slice(index, index + pageSize);
  }
}
const list = [1, 2, 3, 4, 5, 6, 7, 8];
const page = getPage(list, 3); // Generator { }
page.next(); // { value: [1, 2, 3], done: false }
page.next(); // { value: [4, 5, 6], done: false }
page.next(); // { value: [7, 8], done: false }
page.next(); // { value: undefined, done: true }
```

### ジェネレーターへ値を送る

この例では `next` を値付きで呼び出しています。

**メモ:** 最初の呼び出しではジェネレーターが何も生成していないため、何もログを記録しません。


```js
function\* gen() {
  while (true) {
    let value = yield null;
    console.log(value);
  }
}

const g = gen();
g.next(1);
// "{ value: null, done: false }"
g.next(2);
// 2
// "{ value: null, done: false }"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-generator.prototype.next |

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

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

関連情報
----

* `function*`
* イテレーターとジェネレーター
Generator.prototype.throw()
===========================

**`throw()`** メソッドは、ジェネレーターの例外を、エラーを発生させることで再開し、 `done` と `value` の 2 つのプロパティを持ったオブジェクトを返します。

構文
--
```

gen.throw(exception)
```

### 引数

`exception`

発生させる例外。デバッグ時には `instanceof` `Error` を行うと便利です。

### 返値

2 つのプロパティを持つ `Object` です。

`done` (boolean)

* イテレーターが反復処理の末尾を過ぎている場合、値は `true` になります。この場合、 `value` はオプションでそのイテレーターの*返値*を指定します。
* イテレーターが反復処理の次の値を生成することができた場合、値は `false` になります。これは `done` プロパティを指定しない場合も同等です。

`value`

イテレーターが返す何らかの JavaScript の値です。 `done` が `true` の場合は省略可能です。

例
-

### throw() の使用

次の例では、簡単なジェネレーターと、 `throw`メソッドを用いて発生させるエラーを示します。エラーは通常 `try...catch` ブロックによって受け取られます。


```js
function\* gen() {
  while (true) {
    try {
      yield 42;
    } catch (e) {
      console.log("Error caught!");
    }
  }
}

const g = gen();
g.next();
// { value: 42, done: false }
g.throw(new Error("Something went wrong"));
// "Error caught!"
// { value: 42, done: false }
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-generator.prototype.throw |

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

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

関連情報
----

* `function*`
Proxy.revocable()
=================

**`Proxy.revocable()`** メソッドは、取り消し可能な `Proxy` オブジェクトを作成するために使用します。

構文
--


```js
Proxy.revocable(target, handler)
```

### 引数

`target`

`Proxy` でラップする対象のオブジェクトです。これは一連のオブジェクト、例えばネイティブの配列、関数、他のプロキシーなどを取ることもできます。

`handler`

プロキシー `p` に対して操作が行われたときの動作を定義する関数をプロパティとするオブジェクトです。

### 返値

以下の 2 つのプロパティを持つプレーンなオブジェクトです。

`proxy`

`new Proxy(target, handler)` 呼び出しで生成したプロキシーオブジェクトです。

`revoke`

`proxy` を無効にするための引数を持たない関数です。

解説
--

`Proxy.revocable()` はファクトリー関数で、`Proxy()` コンストラクターと同じですが、プロキシーオブジェクトを作成するだけでなく、プロキシーを無効にするために求められる `revoke` 関数を作成します。プロキシーオブジェクトと `revoke` 関数はプレーンオブジェクトにラップされています。

`revoke` 関数は引数を取らず、`this` 値にも頼りません。作成された `proxy` オブジェクトは `revoke` 関数にプライベートプロパティとして結び付けられ、`revoke` 関数が呼び出されたときに自分自身でアクセスします（プライベートプロパティの存在は外からは観測できませんが、ガーベジコレクションが発生する方法については影響があります）。`proxy` オブジェクトは `revoke` 関数のクロージャ内には収容されません（`revoke` がまだ生きている場合、`proxy` のガベージコレクションは不可能になります）。

`revoke()` 関数が呼び出された後、プロキシーは使用できなくなります。ハンドラーのトラップが発生すると `TypeError` が発生します。一度プロキシーが取り消されると、取り消されたままになり、再び `revoke()` を呼び出しても何の効果もありません。実際、`revoke()` を呼び出すと `proxy` オブジェクトを `revoke` 関数から切り離すので、`revoke` 関数が再びプロキシーにアクセスできることは全くありません。プロキシーが他の場所で参照されていない場合、ガベージコレクションの対象となります。`revoke` 関数は `target` と `handler` も `proxy` から切り離すので、`target` が他の場所で参照されていない場合、プロキシーがまだ生きていても、対象のオブジェクトと意味のあるやりとりをする方法がなくなったので、それもガベージコレクションの対象となります。

ユーザーが取り消し可能なプロキシーを通してオブジェクトと対話することで、ユーザーに公開されるオブジェクトのライフタイムを制御できます。ユーザーがまだそのプロキシーを参照しているときでも、オブジェクトをガベージコレクション可能にすることができます。

例
-

### Proxy.revocable() の使用


```js
const revocable = Proxy.revocable(
  {},
  {
    get(target, name) {
      return `[[${name}]]`;
    },
  },
);
const proxy = revocable.proxy;
console.log(proxy.foo); // "[[foo]]"

revocable.revoke();

console.log(proxy.foo); // TypeError が発生
proxy.foo = 1; // TypeError が発生
delete proxy.foo; // これも TypeError
typeof proxy; // "object" と表示。 typeof でトラップは発生しない
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy.revocable |

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

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

関連情報
----

* `Proxy`
Proxy() コンストラクター
================

**`Proxy()`** コンストラクターは `Proxy` オブジェクトを生成するために使用します。

構文
--


```js
new Proxy(target, handler)
```


**メモ:** `Proxy()` は、`new` を使ってのみ構築することができます。`new` なしで呼び出そうとすると、`TypeError` が発生します。

### 引数

`target`

`Proxy` でラップするターゲットのオブジェクトです。あらゆる種類のオブジェクト、例えばネイティブ配列や関数、別のプロキシーなどがなることができます。

`handler`

関数をプロパティとして持つオブジェクトで、その関数で、 Proxy `p` に対して操作が行われた場合の挙動を定義します。

解説
--

`Proxy()` コンストラクターを使用すると、新しい `Proxy` オブジェクトを生成できます。
 このコンストラクターは 2 つの必須の引数を取ります。

* `target` はプロキシーを作成するオブジェクトです。
* `handler` はプロキシーのカスタム動作を定義するオブジェクトです。

handler を空にすると、ほとんどすべての点でターゲットとまったく同じように振る舞うプロキシーを作成します。 `handler` オブジェクト上で関数群のいずれかを定義することで、プロキシーの動作の特定の側面をカスタマイズすることができます。例えば、 `get()` を定義することで、 ターゲットのプロパティアクセサーのカスタマイズされたバージョンを提供することができます。

### ハンドラー関数

この節では、定義することができるすべてのハンドラー関数を列挙します。ハンドラー関数は、対象オブジェクトの呼び出しをトラップするので、*トラップ*と呼ばれることがあります。

`handler.apply()`

関数呼び出しのトラップです。

`handler.construct()`

`new` 演算子のトラップです。

`handler.defineProperty()`

`Object.defineProperty` のトラップです。

`handler.deleteProperty()`

`delete` 演算子のトラップです。

`handler.get()`

プロパティ値の取得のトラップです。

`handler.getOwnPropertyDescriptor()`

`Object.getOwnPropertyDescriptor` のトラップです。

`handler.getPrototypeOf()`

`Object.getPrototypeOf` のトラップです。

`handler.has()`

`in` 演算子のトラップです。

`handler.isExtensible()`

`Object.isExtensible` のトラップです。

`handler.ownKeys()`

`Object.getOwnPropertyNames` や `Object.getOwnPropertySymbols` のトラップです。

`handler.preventExtensions()`

`Object.preventExtensions` のトラップです。

`handler.set()`

プロパティ値の設定のトラップです。

`handler.setPrototypeOf()`

`Object.setPrototypeOf` のトラップです。

例
-

### 選択的にプロパティアクセサーのプロキシーを行う

この例では、ターゲットは `notProxied` と `proxied` の 2 つのプロパティを持っています。 `proxied` に別の値を返し、それ以外のアクセスをターゲットに許可するハンドラーを定義します。


```js
const target = {
  notProxied: "original value",
  proxied: "original value",
};

const handler = {
  get(target, prop, receiver) {
    if (prop === "proxied") {
      return "replaced value";
    }
    return Reflect.get(...arguments);
  },
};

const proxy = new Proxy(target, handler);

console.log(proxy.notProxied); // "original value"
console.log(proxy.proxied); // "replaced value"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-constructor |

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

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

関連情報
----

* JavaScript Guide ガイドの `Proxy` と `Reflect`
* `Reflect`