recursal/MDN huggingface dataset:
NaN
===

グローバルプロパティ **`NaN`** は非数 (Not-A-Number) を表す値です。

| `NaN` のプロパティ属性 |
| --- |
| 書込可能 | 不可 |
| 列挙可能 | 不可 |
| 設定可能 | 不可 |

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

解説
--

`NaN` は**グローバルオブジェクト**のプロパティです。言い換えれば、グローバルスコープにある変数です。

`NaN` の初期値は非数であり、 `Number.NaN` の値と同等です。最近のブラウザーであれば、 `NaN` は設定、書き込みがともに不可能なプロパティとなっています。そうでない場合であっても、オーバーライドは無効となります。プログラムの中で `NaN` を使用するのは、むしろまれなことです。

`NaN` を返す演算には 5 種類があります。

* 数値が解釈できない (例えば `parseInt("blabla")` または `Number(undefined)`)
* 結果が実数にならない数学演算 (例えば `Math.sqrt(-1)`)
* オペランドが `NaN` である (例えば `7 ** NaN`)
* 不確定形 (例えば `0 * Infinity` または `undefined + undefined`)
* 文字列が関わる加算以外の何らかの演算 (例えば `"foo" / 3`)
例
-

### NaN に対するテスト

`NaN` は別の `NaN` 値を含むあらゆる数と (`==`、`!=`、`===`、`!==` によって) 同じではないと比較されます。ある値が `NaN` かどうかを的確に判定するには `Number.isNaN()` か `isNaN()` を使用してください。あるいは自己比較を実行しましょう。 `NaN` は、また `NaN` だけが、自身と同等ではないと比較評価されます。


```js
NaN === NaN; // false
Number.NaN === NaN; // false
isNaN(NaN); // true
isNaN(Number.NaN); // true
Number.isNaN(NaN); // true

function valueIsNaN(v) {
  return v !== v;
}
valueIsNaN(1); // false
valueIsNaN(NaN); // true
valueIsNaN(Number.NaN); // true
```


ただし、 `isNaN()` と `Number.isNaN()` には違いがあることに気をつけてください。前者は、値そのものが `NaN` であったり、値の変換の結果 `NaN` になる場合に `true` を返します。後者は値そのものが `NaN` のときにだけ `true` を返します。


```js
isNaN("hello world"); // true
Number.isNaN("hello world"); // false
```


同じ理由で、 `bigint` 値の場合は `isNaN()` ではエラーが発生しますが、 `Number.isNaN()` では発生しません。


```js
isNaN(1n); // TypeError: Conversion from 'BigInt' to 'number' is not allowed.
Number.isNaN(1n); // false
```


加えて、配列メソッドの中には `NaN` を見つけることができるもの、できないものがあります。


```js
let arr = [2, 4, NaN, 12];
arr.indexOf(NaN); // -1 (false)
arr.includes(NaN); // true
arr.findIndex((n) => Number.isNaN(n)); // 2
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-value-properties-of-the-global-object-nan |

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

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

関連情報
----

* `Number.NaN`
* `Number.isNaN()`
* `isNaN()`
ArrayBuffer
===========

**`ArrayBuffer`** オブジェクトは、一般的な生のバイナリーデータバッファーを表現するために使用します。

これはバイトの配列で、他の言語ではよく「バイト配列」と呼ばれます。`ArrayBuffer` の内容を直接操作することはできません。代わりに、バッファーを特定の形式で表現する型付き配列オブジェクトまたは `DataView` オブジェクトのいずれかを作成して、バッファーの内容を読み書きします。

`ArrayBuffer()` コンストラクターは、指定した長さの `ArrayBuffer` をバイト単位で作成します。既存のデータから、たとえば、Base64 文字列やローカルファイルからから配列バッファーを取得することもできます。

`ArrayBuffer` は移譲可能オブジェクトです。

解説
--

### ArrayBuffer のサイズ変更

`ArrayBuffer` オブジェクトは `maxByteLength` オプションを指定して `ArrayBuffer()` コンストラクターを呼び出すことで、サイズを変更することができるようになります。`ArrayBuffer` がサイズ変更可能かどうか、またその最大サイズを知るには、それぞれ `resizable` と `maxByteLength` のプロパティにアクセスすれば分かります。サイズ変更可能な `ArrayBuffer` には、 `resize()` を呼び出して新しいサイズを割り当てることができます。新しいバイトは 0 に初期化されます。

これらの機能により、`ArrayBuffer` のサイズ変更がより効率的になります。そうしないと、新しいサイズのバッファーのコピーを持たなければなりません。また、この点で JavaScript が WebAssembly と同等になります（WASM のリニアメモリーは `WebAssembly.Memory.prototype.grow()` でサイズ変更が可能です）。

コンストラクター
--------

`ArrayBuffer()`

新しい `ArrayBuffer` オブジェクトを作成します。

静的プロパティ
-------

`get ArrayBuffer[@@species]`

派生オブジェクトを作成する際に使用するコンストラクター関数です。

静的メソッド
------

`ArrayBuffer.isView()`

`arg` が型付き配列オブジェクトや `DataView` のような ArrayBuffer ビューのいずれかである場合は `true` を返します。それ以外の場合は `false` を返します。

インスタンスプロパティ
-----------

これらのプロパティは `ArrayBuffer.prototype` で定義されており、すべての `ArrayBuffer` インスタンスで共有されます。

`ArrayBuffer.prototype.byteLength`

`ArrayBuffer`のサイズをバイト単位で指定します。これは配列の構築時に設定され、`ArrayBuffer` がサイズ変更可能な場合にのみ `ArrayBuffer.prototype.resize()` メソッドを使用して変更することができます。

`ArrayBuffer.prototype.maxByteLength` 
Experimental

読み取り専用で、`ArrayBuffer` のサイズを変更できる最大長をバイト数で指定します。これは配列が構築される際に設定され、変更することはできません。

`ArrayBuffer.prototype.resizable` 
Experimental

読み取り専用。`ArrayBuffer` のサイズを変更できる場合は `true` を、変更できない場合は `false` を返します。

`ArrayBuffer.prototype.constructor`

インスタンスオブジェクトを作成したコンストラクター関数。`ArrayBuffer` インスタンスの場合、初期値は `ArrayBuffer` コンストラクターです。

`ArrayBuffer.prototype[@@toStringTag]`

`@@toStringTag` プロパティの初期値は文字列 `"ArrayBuffer"` です。このプロパティは `Object.prototype.toString()` で使用されます。

インスタンスメソッド
----------

`ArrayBuffer.prototype.slice()`

新しい `ArrayBuffer` に、`begin` (の位置) から `end` (の手前) までのバイトのコピーを入れて返します。`begin` または `end` のどちらかが負の値の場合は、配列の先頭からではなく、配列の末尾からの位置を指します。

`ArrayBuffer.prototype.resize()` 
Experimental

`ArrayBuffer` を指定したサイズ（バイト単位）にサイズ変更します。

例
-

### ArrayBuffer の作成

この例では、バッファーを参照する `Int32Array` ビューを持つ 8 バイトのバッファーを作成します。


```js
const buffer = new ArrayBuffer(8);
const view = new Int32Array(buffer);
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-arraybuffer-objects |

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

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

関連情報
----

* `ArrayBuffer` ポリフィル (`core-js`)
* JavaScript の型付き配列
* `SharedArrayBuffer`
* RangeError: invalid array length
Atomics
=======

**`Atomics`** オブジェクトは、静的なメソッドとして不可分操作を提供します。これらは `SharedArrayBuffer` および `ArrayBuffer` オブジェクトで使用されます。

解説
--

不可分操作は、 `Atomics` モジュール上に装備されています。他のグローバルオブジェクトと異なり、 `Atomics` はコンストラクターではありません。 `new` 演算子と一緒に使用したり、 `Atomics` オブジェクトを関数として呼び出したりすることはできません。 `Atomics` のすべてのプロパティとメソッドは静的です (例えば、`Math` オブジェクトの場合と同様です)。

### 不可分操作

メモリが共有されている場合、複数のスレッドがメモリー内の同じデータを読み書きできます。不可分操作では、予測される値の書き込みと読み込みを保証するため、次の演算が開始される前に現在の演算が完了し、その演算が割り込まれないようにします。

### wait と notify

`wait()` メソッドと `notify()` メソッドは、 Linux の futex ("fast user-space mutex") を原型としており、特定の条件が true になるまで待つ手段を提供します。一般的にはブロッキング構造として使用されます。

静的メソッド
------

`Atomics.add()`

配列の指定した位置にある既存の値に指定した値を追加します。その位置にあった古い値を返します。

`Atomics.and()`

配列の指定した位置の値と指定した値でビット単位の論理積 (AND) を計算します。その位置にあった古い値を返します。

`Atomics.compareExchange()`

値が等しい場合、配列の指定した位置に値を格納します。古い値を返します。

`Atomics.exchange()`

配列の指定した位置に値を格納します。古い値を返します。

`Atomics.isLockFree(size)`

ロック機構と不可分操作のどちらを使用するかを決定するための最適化プリミティブです。指定した要素サイズの配列上の不可分操作が (ロックではなく) ハードウェアによる不可分操作を使用するよう実装されている場合、 `true` を返します。上級者だけが使用してください。

`Atomics.load()`

配列の指定した位置の値を返します。

`Atomics.notify()`

配列の指定した位置で待機中のエージェントに通知します。通知を受けたエージェントの数を返します。

`Atomics.or()`

配列の指定した位置の値と指定した値でビット単位の論理和 (OR) を計算します。その位置にあった古い値を返します。

`Atomics.store()`

配列の指定した位置に指定した値を格納します。その値を返します。

`Atomics.sub()`

配列の指定した位置の値から指定した値を減算します。その位置にあった古い値を返します。

`Atomics.wait()`

配列の指定位置に指定した値が含まれているか検証し、休止して待機するかタイムアウトします。 "`ok`"、"`not-equal`"、"`timed-out`" のいずれかの文字列を返します。呼び出したエージェントで待機が許可されていない場合は、 Error 例外を投げます (ほとんどのブラウザーは、ブラウザーのメインスレッドで `wait()` を許可していません)。

`Atomics.xor()`

配列の指定した位置の値と指定した値でビット単位の排他的論理和 (XOR) を計算します。その位置にあった古い値を返します。

例
-

### Atomics の使用


```js
const sab = new SharedArrayBuffer(1024);
const ta = new Uint8Array(sab);

ta[0]; // 0
ta[0] = 5; // 5

Atomics.add(ta, 0, 12); // 5
Atomics.load(ta, 0); // 17

Atomics.and(ta, 0, 1); // 17
Atomics.load(ta, 0); // 1

Atomics.compareExchange(ta, 0, 5, 12); // 1
Atomics.load(ta, 0); // 1

Atomics.exchange(ta, 0, 12); // 1
Atomics.load(ta, 0); // 12

Atomics.isLockFree(1); // true
Atomics.isLockFree(2); // true
Atomics.isLockFree(3); // false
Atomics.isLockFree(4); // true

Atomics.or(ta, 0, 1); // 12
Atomics.load(ta, 0); // 13

Atomics.store(ta, 0, 12); // 12

Atomics.sub(ta, 0, 2); // 12
Atomics.load(ta, 0); // 10

Atomics.xor(ta, 0, 1); // 10
Atomics.load(ta, 0); // 11
```

### 待機と通知

共有された `Int32Array` があるとします。


```js
const sab = new SharedArrayBuffer(1024);
const int32 = new Int32Array(sab);
```


読み取りスレッドはスリープ状態で、 0 の位置が 0 である間は待機しています。これが true である限り、スレッドは進みません。しかし、書き込みスレッドが新しい値を格納すると、書き込みスレッドから通知され、新しい値 (123) を返します。


```js
Atomics.wait(int32, 0, 0);
console.log(int32[0]); // 123
```


書き込みスレッドが新しい値を格納し、待機しているスレッドに書き込みが発生したことを通知します。


```js
console.log(int32[0]); // 0;
Atomics.store(int32, 0, 123);
Atomics.notify(int32, 0, 1);
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-atomics-object |

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

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

関連情報
----

* `ArrayBuffer`
* JavaScript 型付き配列
* ウェブワーカー
* parlib-simple – 同期と分配の抽象化を行うシンプルなライブラリー。
* Shared Memory – 短いチュートリアル
* JavaScript の並列処理機能を味見してみる – Mozilla Hacks
AsyncIterator
=============

**`AsyncIterator`** オブジェクトは 非同期イテレータープロトコル に準拠したオブジェクトで、 `next()` メソッドを提供することでイテレーターの結果オブジェクトに履行されるプロミスを返します。 `AsyncIterator.prototype` オブジェクトは、すべての組み込み非同期イテレーターが継承する非表示のグローバルオブジェクトです。これは、非同期イテレーターオブジェクト自身を返す `@@asyncIterator` メソッドを提供し、非同期イテレーターを非同期反復可能にもします。

なお、`AsyncIterator` はグローバルオブジェクトではありませんが、将来的には async iterator helpers proposal でグローバルオブジェクトになる予定です。すべての組み込み非同期イテレーターで共有される `AsyncIterator.prototype` オブジェクトは以下のコードで取得できます。


```js
const AsyncIteratorPrototype = Object.getPrototypeOf(
  Object.getPrototypeOf(Object.getPrototypeOf((async function\* () {})())),
);
```

解説
--

現在、 JavaScript の組み込み非同期イテレーターは、非同期ジェネレーター関数が返す `AsyncGenerator` オブジェクトだけです。ウェブ API には他にも `ReadableStream` のような組み込みの非同期イテレーターがあります。

これらの非同期イテレーターはそれぞれ個別のプロトタイプオブジェクトを持っており、特定の非同期イテレーターが使用する `next()` メソッドを定義しています。これらのプロトタイプオブジェクトはすべて `AsyncIterator.prototype` を継承しています。これは非同期イテレータオブジェクト自身を返す `@@asyncIterator` メソッドを提供し、非同期イテレーターを非同期反復可能にもします。

**メモ:** `AsyncIterator.prototype` は `@@iterator` を実装していないので、非同期イテレーターは既定では同期反復可能ではありません。

インスタンスメソッド
----------

`AsyncIterator.prototype[@@asyncIterator]()`

非同期イテレーターオブジェクト自身を返します。これにより、非同期イテレーターオブジェクトも非同期反復可能オブジェクトになります。

例
-

### 非同期イテレーターを非同期反復可能として使用

すべての組み込み非同期イテレーターも非同期反復処理可能オブジェクトなので、`for await...of` ループで使用することができます。


```js
const asyncIterator = (async function\* () {
  yield 1;
  yield 2;
  yield 3;
})();
(async () => {
  for await (const value of asyncIterator) {
    console.log(value);
  }
})();
// ログ: 1, 2, 3
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-asynciteratorprototype |

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

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

関連情報
----

* `async function*`
* イテレータープロトコル
ReferenceError
==============

**`ReferenceError`** オブジェクトは存在しない変数が参照された場合のエラーを表します。

コンストラクター
--------

`ReferenceError()`

新しい `ReferenceError` オブジェクトを生成します。

インスタンスプロパティ
-----------

`ReferenceError.prototype.message`

エラーメッセージです。 ECMA-262 において `ReferenceError` は自身の `message` プロパティを提供するべきとされていますが、 SpiderMonkey では `Error.prototype.message` を継承しています。

`ReferenceError.prototype.name`

エラー名です。 `Error` から継承しています。

`ReferenceError.prototype.fileName`

このエラーが発生したファイルのパスです。 `Error` から継承しています。

`ReferenceError.prototype.lineNumber`

このエラーが発生したファイル内の行番号です。 `Error` から継承しています。

`ReferenceError.prototype.columnNumber`

このエラーが発生した行内の桁番号です。 `Error` から継承しています。

`ReferenceError.prototype.stack`

スタックトレースです。 `Error` から継承しています。

例
-

### ReferenceError のキャッチ


```js
try {
  let a = undefinedVariable;
} catch (e) {
  console.log(e instanceof ReferenceError); // true
  console.log(e.message); // "undefinedVariable is not defined"
  console.log(e.name); // "ReferenceError"
  console.log(e.fileName); // "Scratchpad/1"
  console.log(e.lineNumber); // 2
  console.log(e.columnNumber); // 6
  console.log(e.stack); // "@Scratchpad/2:2:7\n"
}
```

### ReferenceError の生成


```js
try {
  throw new ReferenceError("Hello", "someFile.js", 10);
} catch (e) {
  console.log(e instanceof ReferenceError); // true
  console.log(e.message); // "Hello"
  console.log(e.name); // "ReferenceError"
  console.log(e.fileName); // "someFile.js"
  console.log(e.lineNumber); // 10
  console.log(e.columnNumber); // 0
  console.log(e.stack); // "@Scratchpad/2:2:9\n"
}
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-native-error-types-used-in-this-standard-referenceerror |

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

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

関連情報
----

* `Error`
Infinity
========

グローバルプロパティ **`Infinity`** は無限大を表す数値です。

| `Infinity` のプロパティ属性 |
| --- |
| 書込可能 | 不可 |
| 列挙可能 | 不可 |
| 設定可能 | 不可 |

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

解説
--

`Infinity` は*グローバルオブジェクト*のプロパティです。言い換えればグローバルスコープ内の変数です。

`Infinity` の初期値は `Number.POSITIVE_INFINITY` です。`Infinity` という値 (正の無限大) は他のあらゆる数より大きい数です。

この値は数学的に無限大のように振る舞います。詳しくは `Number.POSITIVE_INFINITY` を参照してください。

ECMAScript 5 の仕様では、`Infinity` は読み取り専用です (JavaScript 1.8.5 / Firefox 4 にて実装)。

例
-

### Infinity の使用


```js
console.log(Infinity); /\* Infinity \*/
console.log(Infinity + 1); /\* Infinity \*/
console.log(Math.pow(10, 1000)); /\* Infinity \*/
console.log(Math.log(0)); /\* -Infinity \*/
console.log(1 / Infinity); /\* 0 \*/
console.log(1 / 0); /\* Infinity \*/
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-value-properties-of-the-global-object-infinity |

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

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

関連情報
----

* `Number.NEGATIVE_INFINITY`
* `Number.POSITIVE_INFINITY`
* `Number.isFinite`
AsyncFunction
=============

Baseline Widely available
-------------------------

This feature is well established and works across many devices and browser versions. It’s been available across browsers since April 2017.

* Learn more
* See full compatibility
* Report feedback
**`AsyncFunction`** オブジェクトは、非同期関数のメソッドを提供します。JavaScript では、すべての非同期関数が実際に `AsyncFunction` オブジェクトです。

`AsyncFunction` はグローバルオブジェクトでは*ない*ことに注意してください。これは以下のようなコードで取得することができます。


```js
const AsyncFunction = async function () {}.constructor;
```


`AsyncFunction` は `Function` のサブクラスです。

コンストラクター
--------

`AsyncFunction()`

新しい `AsyncFunction` オブジェクトを生成します。

インスタンスプロパティ
-----------

*インスタンスプロパティを親である `Function` から継承しています*。

これらのプロパティは `AsyncFunction.prototype` で定義されており、すべての `AsyncFunction` のインスタンスで共有されます。

`AsyncFunction.prototype.constructor`

インスタンスオブジェクトを作成したコンストラクター関数。`AsyncFunction` インスタンスの場合、初期値は `AsyncFunction` コンストラクターです。

`AsyncFunction.prototype[@@toStringTag]`

`@@toStringTag` プロパティの初期値は、文字列 `"AsyncFunction"` です。このプロパティは `Object.prototype.toString()` で使用されます。


**メモ:** `AsyncFunction` のインスタンスには `prototype` プロパティがありません。

インスタンスメソッド
----------

*インスタンスメソッドを親である `Function` から継承しています*。

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-async-function-objects |

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

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

関連情報
----

* `async function` 宣言
* `async function` 式
* `Function`
* `AsyncGeneratorFunction`
* `GeneratorFunction`
* 関数
URIError
========

**`URIError`** オブジェクトは、グローバル URI 処理関数が間違った方法で使用された場合のエラーを表します。

コンストラクター
--------

`URIError()`

新しい `URIError` オブジェクトを生成します。

インスタンスプロパティ
-----------

`URIError.prototype.message`

エラーメッセージです。 ECMA-262 において `URIError` は自身の `message` プロパティを提供するべきとされていますが、 SpiderMonkey では `Error.prototype.message` を継承しています。

`URIError.prototype.name`

エラー名です。 `Error` から継承しています。

`URIError.prototype.fileName`

このエラーが発生したファイルのパスです。 `Error` から継承しています。

`URIError.prototype.lineNumber`

このエラーが発生したファイル内の行番号です。 `Error` から継承しています。

`URIError.prototype.columnNumber`

このエラーが発生した行内の桁番号です。 `Error` から継承しています。

`URIError.prototype.stack`

スタックトレースです。 `Error` から継承しています。

例
-

### URIError のキャッチ


```js
try {
  decodeURIComponent("%");
} catch (e) {
  console.log(e instanceof URIError); // true
  console.log(e.message); // "malformed URI sequence"
  console.log(e.name); // "URIError"
  console.log(e.fileName); // "Scratchpad/1"
  console.log(e.lineNumber); // 2
  console.log(e.columnNumber); // 2
  console.log(e.stack); // "@Scratchpad/2:2:3\n"
}
```

### URIError の生成


```js
try {
  throw new URIError("Hello", "someFile.js", 10);
} catch (e) {
  console.log(e instanceof URIError); // true
  console.log(e.message); // "Hello"
  console.log(e.name); // "URIError"
  console.log(e.fileName); // "someFile.js"
  console.log(e.lineNumber); // 10
  console.log(e.columnNumber); // 0
  console.log(e.stack); // "@Scratchpad/2:2:9\n"
}
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-native-error-types-used-in-this-standard-urierror |

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

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

関連情報
----

* `Error`
* `decodeURI()`
* `decodeURIComponent()`
* `encodeURI()`
* `encodeURIComponent()`
GeneratorFunction
=================

**`GeneratorFunction` コンストラクター**は、新しいジェネレーター関数オブジェクトを生成します。 JavaScript では、すべてのジェネレーター関数が実際に `GeneratorFunction` オブジェクトです。

`GeneratorFunction` はグローバルオブジェクトではないことに注意してください。次のコードを評価することによって得られます。


```js
Object.getPrototypeOf(function\* () {}).constructor;
```

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

構文
--
```

new GeneratorFunction ([arg1[, arg2[, ...argN]],] functionBody)
```

### 引数

`arg1, arg2, ... argN`

形式的な引数名として関数に使用される名前です。それぞれが有効な JavaScript の識別子であるか、カンマで区切った文字列のリストで、例えば "`x`", "`theValue`", "`a,b`" などです。

`functionBody`

関数定義を構成する JavaScript 文を含む文字列。

解説
--

`GeneratorFunction` コンストラクターで生成されたジェネレーター関数オブジェクトは、関数が生成されたときにパースされます。これは、ジェネレーター関数を `function* 式`で定義してからコード内で呼び出す方法ほど効率的ではありません。というのも、そのような関数はコードの残りの部分と共にパースされるからです。

関数に渡されたすべての引数は、渡された順に、作成される関数内の引数の識別子の名前として扱われます。

**メモ:** `ジェネレーター関数`が `GeneratorFunction` コンストラクターによって生成された場合、生成コンテキストのクロージャは作成されません。常にグローバルスコープに生成されます。

実行すると、ローカル変数とグローバルグローバル変数にのみアクセスでき、 `GeneratorFunction` コンストラクターが呼び出されたスコープの変数にはアクセスできません。

これは、ジェネレーター関数式のコードで `eval` を使用した場合とは異なります。

`GeneratorFunction` コンストラクターを (`new` 演算子を使用せずに) 関数として呼び出した場合、コンストラクターとして呼び出したときと同じ効果があります。

例
-

### GeneratorFunction() コンストラクターからジェネレーター関数を生成する


```js
var GeneratorFunction = Object.getPrototypeOf(function\* () {}).constructor;
var g = new GeneratorFunction("a", "yield a \* 2");
var iterator = g(10);
console.log(iterator.next().value); // 20
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-generatorfunction-objects |

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

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

関連情報
----

* function\* 関数
* function\* 式
* `Function`
* 関数文
* 関数式
* 関数と関数スコープ
Generator
=========

**`Generator`** オブジェクトはジェネレーター関数によって返され、反復可能プロトコルとイテレータープロトコルの両方に準拠しています。

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

コンストラクター
--------

このオブジェクトを直接インスタンス化することはできません。代わりに、ジェネレーター関数から `Generator` のインスタンスを返すことができます。
```

function* generator() {
  yield 1;
  yield 2;
  yield 3;
}

const gen = generator(); // "Generator { }"
```

インスタンスメソッド
----------

`Generator.prototype.next()`

`yield` 式で得られた値を返します。

`Generator.prototype.return()`

与えられた値を返し、ジェネレーターを終了します。

`Generator.prototype.throw()`

ジェネレーターにエラーを投げます。（そのジェネレーターの中からキャッチされない限り、ジェネレーターも終了します）

例
-

### 無限イテレーター


```js
function\* infinite() {
  let index = 0;

  while (true) {
    yield index++;
  }
}

const generator = infinite(); // "Generator { }"

console.log(generator.next().value); // 0
console.log(generator.next().value); // 1
console.log(generator.next().value); // 2
// ...
```

仕様
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-generator-objects |

ブラウザー実装状況
---------

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

関連情報
----

* `function*`
* `function*` 式
* `GeneratorFunction`
* 反復処理プロトコル (en-US)
AsyncGeneratorFunction
======================

**`AsyncGeneratorFunction`** オブジェクトは、非同期ジェネレータ関数 のメソッドを提供します。 JavaScript で、すべての非同期ジェネレータ関数は実際には `AsyncGeneratorFunction` オブジェクトです。

なお、`AsyncGeneratorFunction` はグローバルオブジェクトではありません。以下のコードで取得できます。


```js
const AsyncGeneratorFunction = async function\* () {}.constructor;
```


`AsyncGeneratorFunction` は `Function` のサブクラスです。

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

コンストラクター
--------

`AsyncGeneratorFunction()`

新しい `AsyncGeneratorFunction` オブジェクトを生成します。

インスタンスプロパティ
-----------

*親である `Function` から継承したインスタンスプロパティもあります*。

これらのプロパティは `AsyncGeneratorFunction.prototype` で定義されており、すべての `AsyncGeneratorFunction` インスタンスで共有されます。

`AsyncGeneratorFunction.prototype.constructor`

このインスタンスオブジェクトを生成したコンストラクター関数です。 `AsyncGeneratorFunction` インスタンスにおいては、初期値は `AsyncGeneratorFunction` コンストラクターです。

`AsyncGeneratorFunction.prototype.prototype`

すべての非同期ジェネレータ関数は同じ `prototype` プロパティを共有していて、それは `AsyncGenerator.prototype` です。それぞれの非同期ジェネレーター関数のインスタンスは自分自身で `prototype` プロパティも持ちます。非同期ジェネレーター関数が呼び出されると、返される非同期ジェネレーターオブジェクトは非同期ジェネレーター関数の `prototype` プロパティを継承し、そのプロパティは `AsyncGeneratorFunction.prototype` を継承します。

`AsyncGeneratorFunction.prototype[@@toStringTag]`

`@@toStringTag` プロパティの初期値は文字列 `"AsyncGeneratorFunction"` です。このプロパティは `Object.prototype.toString()` で使用します。

インスタンスメソッド
----------

*親である `Function` からインスタンスメソッドを継承しています*。

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-asyncgeneratorfunction-objects |

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

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

関連情報
----

* `async function*` 宣言
* `async function*` 式
* `Function`
* `AsyncFunction`
* `GeneratorFunction`
* Functions
TypeError
=========

**`TypeError`** オブジェクトは、演算が実行できなくなった時の新しいエラーを表します。特に値が期待された型ではなかった場合です (ただし、それに限りません)。

`TypeError` は以下のような場合に発生します。

* 関数に渡されたオペランドや引数が、その演算子や関数で期待された型と互換性がなかった場合
* 変更できない値を変更しようとした場合
* 適切ではない方法で値を使用しようとした場合
コンストラクター
--------

`TypeError()`

新しい `TypeError` オブジェクトを生成します。

インスタンスプロパティ
-----------

`TypeError.prototype.message`

エラーメッセージです。 ECMA-262 において `TypeError` は自身の `message` プロパティを提供するべきとされていますが、 SpiderMonkey では `Error.prototype.message` を継承しています。

`TypeError.prototype.name`

エラー名です。 `Error` から継承しています。

`TypeError.prototype.fileName`

このエラーが発生したファイルのパスです。 `Error` から継承しています。

`TypeError.prototype.lineNumber`

このエラーが発生したファイル内の行番号です。 `Error` から継承しています。

`TypeError.prototype.columnNumber`

このエラーが発生した行内の桁番号です。 `Error` から継承しています。

`TypeError.prototype.stack`

スタックトレースです。 `Error` から継承しています。

例
-

### TypeError のキャッチ


```js
try {
  null.f();
} catch (e) {
  console.log(e instanceof TypeError); // true
  console.log(e.message); // "null has no properties"
  console.log(e.name); // "TypeError"
  console.log(e.fileName); // "Scratchpad/1"
  console.log(e.lineNumber); // 2
  console.log(e.columnNumber); // 2
  console.log(e.stack); // "@Scratchpad/2:2:3\n"
}
```

### TypeError の生成


```js
try {
  throw new TypeError("Hello", "someFile.js", 10);
} catch (e) {
  console.log(e instanceof TypeError); // true
  console.log(e.message); // "Hello"
  console.log(e.name); // "TypeError"
  console.log(e.fileName); // "someFile.js"
  console.log(e.lineNumber); // 10
  console.log(e.columnNumber); // 0
  console.log(e.stack); // "@Scratchpad/2:2:9\n"
}
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-native-error-types-used-in-this-standard-typeerror |

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

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

関連情報
----

* `Error`
globalThis
==========

**`globalThis`** はグローバルプロパティで、グローバルオブジェクトと同等であるグローバルな `this` が格納されています。

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

| `globalThis` のプロパティ属性 |
| --- |
| 書込可能 | 可 |
| 列挙可能 | 不可 |
| 設定可能 | 可 |

解説
--

 従来、グローバルスコープにアクセスするには、JavaScript 環境ごとに異なる構文を必要としていました。ウェブ上では `window`, `self`, `frames` を使うことができます。しかし Web Worker は `self` のみを利用することができます。Node.js はこれらのいずれも利用できず、代わりに `global` を使用する必要があります。
 `this` キーワードは、strict でないモードで実行されている関数の中で使用することもできますが、strict モードで実行されているモジュールや関数の中では `undefined` になります。`Function('return this')()` を使用することもできますが、CSP などによって `eval()` (en-US) を無効にしている環境では、この方法でも `Function` の使用が抑制されます。

`globalThis` プロパティは、環境を越えてグローバルな `this` 値 (すなわちグローバルオブジェクト自身) にアクセスするための標準的な方法を提供します。`window` や `self` などの同様のプロパティとは異なり、これはウィンドウのコンテキストでも非ウィンドウのコンテキストでも動作することが保証されています。この方法では、コードがどの環境で実行されているのかを知らなくても、一貫した方法でグローバルオブジェクトにアクセスすることができます。名前を覚えやすくするために、グローバルスコープでは `this` の値は `globalThis` であることを忘れないでください。

### HTML と WindowProxy

多くのエンジンでは `globalThis` は実在のグローバルオブジェクトの参照になりますが、ウェブブラウザーにおいては、iframe およびウィンドウ間のセキュリティ上の配慮から、これは (直接アクセスできない) 実在のグローバルオブジェクトに関する `Proxy` になります。一般的な利用に関わることは稀ですが、認識しておくことは重要です。

### 命名

`self` や `global` のような他の一般的な名前の選択肢は、既存のコードとの互換性を損なう可能性があるため、候補から除外されました。詳しくは language proposal's "naming" document を参照してください。

例
-

### 異なる環境間でグローバルの検索

`globalThis` 以前は、その環境のグローバルオブジェクトを取得する信頼性の高い方法は `Function('return this')()` だけでした。ただし、これは設定によっては CSP 違反が発生するため、es6-shim では次のようなチェックを使用します。


```js
var getGlobal = function () {
  if (typeof self !== "undefined") {
    return self;
  }
  if (typeof window !== "undefined") {
    return window;
  }
  if (typeof global !== "undefined") {
    return global;
  }
  throw new Error("unable to locate global object");
};

var globals = getGlobal();

if (typeof globals.setTimeout !== "function") {
  // no setTimeout in this environment!
}
```


`globalThis` が利用可能になったため、異なる環境間でグローバルを追加で検索する必要がなくなりました。


```js
if (typeof globalThis.setTimeout !== "function") {
  // no setTimeout in this environment!
}
```

仕様
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-globalthis |

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

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

関連情報
----

* `this`