recursal/MDN huggingface dataset:
ArrayBuffer.prototype.resize()
==============================

**Experimental:** **これは実験的な機能です。**  
本番で使用する前にブラウザー互換性一覧表をチェックしてください。

**`resize()`** は `ArrayBuffer` インスタンスのメソッドで、この `ArrayBuffer` を指定されたサイズ（バイト単位）にサイズ変更します。

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

構文
--


```js
resize(newLength)
```

### 引数

`newLength`

`ArrayBuffer` のサイズを変更する新しい長さ（バイト単位）です。

### 返値

`undefined` です。

### 例外

`TypeError`

`ArrayBuffer` が切り離されているか、サイズ変更できない場合に発生します。

`RangeError`

`newLength`が `ArrayBuffer` の `maxByteLength` より大きい場合に発生します。

解説
--

`resize()` メソッドは `ArrayBuffer` を `newLength` 引数で指定された大きさへサイズ変更します。 ただし、`ArrayBuffer` がサイズ変更可能で、新しいサイズが `ArrayBuffer` の `maxByteLength` 以下であることが条件です。新しいバイトは 0 に初期化されます。

また、`resize()` を使用すると、`ArrayBuffer` を成長させるだけでなく、縮小させることができることに注意してください。`newLength` が `ArrayBuffer` の現在の `byteLength` より小さくなることが許容されています。

例
-

### resize() の使用

この例では、最大16バイトの長さにサイズ変更可能な8バイトのバッファーを作成し、`resizable` プロパティを調べて、`resizable` が true を返した場合にサイズを変更します。


```js
const buffer = new ArrayBuffer(8, { maxByteLength: 16 });

if (buffer.resizable) {
  console.log("Buffer is resizable!");
  buffer.resize(12);
}
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-arraybuffer.prototype.resize |

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

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

関連情報
----

* `ArrayBuffer`
* `ArrayBuffer.prototype.resizable`
* `ArrayBuffer.prototype.maxByteLength`
Set.prototype.keys()
====================

**`keys()`** は `Set` インターフェイスのメソッドで、 `values()` メソッドの別名です。

構文
--


```js
keys()
```

### 引数

なし。

### 返値

新しい反復可能なイテレーターオブジェクトです。

例
-

### keys() の使用

`keys()` メソッドは `values()` メソッドとまったく同じです。


```js
const mySet = new Set();
mySet.add("foo");
mySet.add("bar");
mySet.add("baz");

const setIter = mySet.keys();

console.log(setIter.next().value); // "foo"
console.log(setIter.next().value); // "bar"
console.log(setIter.next().value); // "baz"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.keys |

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

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

関連情報
----

* `Set.prototype.entries()`
* `Set.prototype.values()`
Set[@@species]
==============

**`Set[@@species]`** アクセサープロパティは、`Set` オブジェクトのコピー方法を指定する未使用のアクセッサープロパティです。

構文
--


```js
Set[Symbol.species]
```

### 返値

`get @@species` が呼び出されたコンストラクター (`this`) の値です。この返値は、コピーされた `Set` インスタンスを生成するために使用されます。

解説
--

`@@species` アクセサープロパティは、 `Set` オブジェクトの既定のコンストラクターを返します。サブクラスのコンストラクターはコンストラクターに代入することで、これをオーバーライドすることができます。

**メモ:** このプロパティは現在、 `Set` のどのメソッドでも使用されていません。

例
-

### 通常のオブジェクトの species

`@@species` プロパティは、既定のコンストラクター関数、すなわち `Set` の `Set` コンストラクターを返します。


```js
Set[Symbol.species]; // Set() 関数
```

### 派生オブジェクトの species

独自の `Set` のサブクラス、例えば `MySet` のインスタンス内では、 `MySet` の species は `MySet` コンストラクターです。しかし、派生クラスのメソッドで、親である `Set` オブジェクトを返すためにこれをオーバーライドしたいかもしれません。


```js
class MySet extends Set {
  // MySet species を親である Set コンストラクターにオーバーライド。
  static get [Symbol.species]() {
    return Set;
  }
}
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-set-@@species |

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

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

関連情報
----

* `Set`
* `Symbol.species`
Set.prototype.size
==================

**`size`** は `Set` インスタンスのアクセサープロパティで、この集合内の（固有の）要素の数を返します。

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

解説
--

`size` の値は、`Set` オブジェクトがいくつの要素を持つかを表す整数値です。`size` に対するセットアクセサー関数は `undefined` です。よって、このプロパティは変更できません。

例
-

### size の使用


```js
const mySet = new Set();
mySet.add(1);
mySet.add(5);
mySet.add("some text");

console.log(mySet.size); // 3
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-set.prototype.size |

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

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

関連情報
----

* `Set`
Set.prototype[@@iterator]()
===========================

**`[@@iterator]()`** は `Set` インスタンスのメソッドで、反復処理プロトコルを実装しており、 `Set` オブジェクトを、反復可能オブジェクトを期待するほとんどの構文、例えばスプレッド構文 や `for...of` ループなどで利用できるようにします。これは、挿入順に集合の値を返す集合イテレーターオブジェクトを返します。

**`@@iterator`** プロパティの初期値は `Set.prototype.values` プロパティの初期値と同じ関数オブジェクトです。

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

構文
--


```js
set[Symbol.iterator]()
```

### 引数

なし。

### 返値

`Set.prototype.values()` と同じく、値の集合を生成する新しい反復可能なイテレーターオブジェクトを返します。

例
-

### for...of ループを使用した反復処理

このメソッドを直接呼び出す必要はほとんどないことに注意してください。`@@iterator` メソッドの存在によって `Set` オブジェクトは反復可能になり、`for...of` 文のような反復処理の構文は自動的にこのメソッドを呼ぶことで反復処理を行うためのイテレーターを取得できるようになります。


```js
const mySet = new Set();
mySet.add("0");
mySet.add(1);
mySet.add({});

for (const v of mySet) {
  console.log(v);
}
```

### 手動でイテレーターを扱う

反復処理を最大限に制御するために、返されたイテレーターオブジェクトの `next()` メソッドを手動で呼び出すことも可能です。


```js
const mySet = new Set();
mySet.add("0");
mySet.add(1);
mySet.add({});

const setIter = mySet[Symbol.iterator]();

console.log(setIter.next().value); // "0"
console.log(setIter.next().value); // 1
console.log(setIter.next().value); // Object
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype-@@iterator |

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

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

関連情報
----

* `Set`
* `Set.prototype.entries()`
* `Set.prototype.keys()`
* `Set.prototype.values()`
* `Symbol.iterator`
* 反復可能プロトコル
Set.prototype.values()
======================

**`values()`** は `Set` インターフェイスのメソッドで、集合の新しいイテレーターオブジェクトを返します。これはこの集合のそれぞれの要素をの値を挿入順に返します。

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

構文
--


```js
values()
```

### 引数

なし。

### 返値

新しい反復可能なイテレーターオブジェクトです。

例
-

### values() の使用


```js
const mySet = new Set();
mySet.add("foo");
mySet.add("bar");
mySet.add("baz");

const setIter = mySet.values();

console.log(setIter.next().value); // "foo"
console.log(setIter.next().value); // "bar"
console.log(setIter.next().value); // "baz"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.values |

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

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

関連情報
----

* `Set.prototype.entries()`
* `Set.prototype.keys()`
Set() コンストラクター
==============

**`Set()`** コンストラクターは `Set` オブジェクトを生成します。

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

構文
--


```js
new Set()
new Set(iterable)
```


**メモ:** `Set()` は `new` を付けてのみ構築することができ案す。 `new` 無しで呼び出そうとすると `TypeError` が発生します。

### 引数

`iterable` 省略可

反復可能オブジェクトが渡された場合は、そのすべての要素が新しい `Set` に加えられます。

この引数を指定しなかった場合、または値が `null` だった場合、新しい `Set` は空になります。

### 返値

新しい `Set` オブジェクトです。

例
-

### `Set` オブジェクトの使用


```js
const mySet = new Set();

mySet.add(1); // Set [ 1 ]
mySet.add(5); // Set [ 1, 5 ]
mySet.add(5); // Set [ 1, 5 ]
mySet.add("some text"); // Set [ 1, 5, 'some text' ]
const o = { a: 1, b: 2 };
mySet.add(o);
```

仕様書
---

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

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

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

関連情報
----

* `Set` のポリフィル (`core-js`)
* `Set`
Set.prototype.entries()
=======================

**`entries()`** は `Set` インターフェイスのメソッドで、集合の新しいイテレーターオブジェクトを返します。これは **`[value, value]` の配列**の形で集合の各要素を挿入順に返します。 `Set` オブジェクトは、`Map` オブジェクトのように `key` を持つことはありません。しかしながら、`Map` オブジェクトと似た API をもつために、それぞれの項目は *key* と *value* に対して同じ値を持ちます。そのため、配列 `[value, value]` が返されます。

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

構文
--


```js
entries()
```

### 引数

なし。

### 返値

新しい反復可能なイテレーターオブジェクトです。

例
-

### entries() の使用


```js
const mySet = new Set();
mySet.add("foobar");
mySet.add(1);
mySet.add("baz");

const setIter = mySet.entries();

console.log(setIter.next().value); // ["foobar", "foobar"]
console.log(setIter.next().value); // [1, 1]
console.log(setIter.next().value); // ["baz", "baz"]
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.entries |

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

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

関連情報
----

* `Set.prototype.keys()`
* `Set.prototype.values()`
Set.prototype.has()
===================

**`has()`** は `Set` インターフェイスのメソッドで、指定された値をもつ要素がこの集合内に存在するかどうかを示す論理値を返します。

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

構文
--


```js
has(value)
```

### 引数

`value`

この `Set` オブジェクトに存在するかを検査する値です。

### 返値

この `Set` オブジェクト内に指定された値をもつ要素が存在していたら `true` を返します。さもなければ `false` を返します。

例
-

### has() メソッドの使用


```js
const mySet = new Set();
mySet.add("foo");

console.log(mySet.has("foo")); // true
console.log(mySet.has("bar")); // false

const set1 = new Set();
const obj1 = { key1: 1 };
set1.add(obj1);

console.log(set1.has(obj1)); // true
console.log(set1.has({ key1: 1 })); // オブジェクト参照が異なるため false を返す
console.log(set1.add({ key1: 1 })); // set1 には 2 つの項目が含まれるようになる
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.has |

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

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

関連情報
----

* `Set`
* `Set.prototype.add()`
* `Set.prototype.delete()`
Set.prototype.add()
===================

**`add()`** は `Set` インスタンスのメソッドで、この集合に同じ値を持つ要素がない場合、指定した値を持つ新しい要素をこの集合に追加します。

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

構文
--


```js
add(value)
```

### 引数

`value`

`Set` オブジェクトに追加する要素の値です。

### 返値

追加された値を持つ `Set` オブジェクトです。

例
-

### add() メソッドの使用


```js
const mySet = new Set();

mySet.add(1);
mySet.add(5).add("some text"); // 連鎖可能

console.log(mySet);
// Set [1, 5, "some text"]
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.add |

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

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

関連情報
----

* `Set`
* `Set.prototype.delete()`
* `Set.prototype.has()`
Set.prototype.clear()
=====================

**`clear()`** は `Set` インターフェイスのメソッドで、この集合からすべての要素を取り除きます。

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

構文
--


```js
clear()
```

### 引数

なし。

### 返値

なし (`undefined`)。

例
-

### clear() メソッドの使用


```js
const mySet = new Set();
mySet.add(1);
mySet.add("foo");

console.log(mySet.size); // 2
console.log(mySet.has("foo")); // true

mySet.clear();

console.log(mySet.size); // 0
console.log(mySet.has("bar")); // false
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.clear |

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

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

関連情報
----

* `Set`
* `Set.prototype.delete()`
Set.prototype.delete()
======================

**`delete()`** は `Set` インターフェイスのメソッドで、指定された値がこの集合にあれば、取り除きます。

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

構文
--


```js
setInstance.delete(value)
```

### 引数

`value`

`Set` から取り除く要素の値です。

### 返値

`true` ならば `value` が既に `Set` に存在していたことを表します。そうでなければ `false` を返します。

例
-

### delete() メソッドの使用


```js
const mySet = new Set();
mySet.add("foo");

mySet.delete("bar"); // 削除するべき要素が見つからなければ false を返す
mySet.delete("foo"); // 正常に要素を削除出来れば true を返す

mySet.has("foo"); // 存在しない要素を確認すると false を返す
```

### Set からオブジェクトを削除する

オブジェクト同士は参照で比較されるため、元のオブジェクトへの参照を保持していない場合は、個々のプロパティをチェックして削除する必要があります。


```js
const setObj = new Set(); // 新しいセットを作成

setObj.add({ x: 10, y: 20 }); // セットにオブジェクトを追加

setObj.add({ x: 20, y: 30 }); // セットにオブジェクトを追加

// `x > 10` のポイントを削除
setObj.forEach((point) => {
  if (point.x > 10) {
    setObj.delete(point);
  }
});
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.delete |

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

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

関連情報
----

* `Set`
* `Set.prototype.clear()`
Set.prototype.forEach()
=======================

**`forEach()`** は `Set` インターフェイスのメソッドで、指定された関数をこの集合のそれぞれの値に対して一回ずつ、挿入順で実行します。

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

構文
--


```js
forEach(callbackFn)
forEach(callbackFn, thisArg)
```

### 引数

`callback`

この集合のそれぞれの項目に対して実行する関数です。この関数は次の引数で呼び出されます。

`value`

それぞれの反復処理の値です。

`key`

それぞれの反復処理のキーです。これは常に `value` と同じです。

`set`

反復処理が行われる集合です。


`thisArg` 省略可

`callbackFn` を実行するときｎ、`this` として使用する値です。

### 返値

`undefined` です。

解説
--

`forEach()` メソッドは、この `Set` オブジェクトに実際に存在するそれぞれの値に対して、指定された `callback` を一回ずつ実行します。削除された値に対しては呼び出しません。ただし、`undefined` の値をもつ要素に対しては実行します。

`callback` は **3 つの引数**で呼び出されます。

* この**要素の値**
* この**要素のキー**
* **走査を行っている `Set` オブジェクト**

しかし、 `Set` オブジェクトにキーがないので、最初の 2 つの引数は、両方とも `Set` に含まれる**値**です。これにより、他の `Map` や `Array` の `forEach()` メソッドと整合が取れています。

`thisArg` 引数が `forEach()` に渡された場合、 `callback` を呼び出すときにこれが渡され、 `this` 値として使用されます。渡されなかった場合は、さもなければ、`this` 値として使用するために `undefined` 値が渡されます。 `this` の値が最終的に `callback` から見える姿は、関数から見た `this` を決定するための通常のルールに応じて決まります。

それぞれの値は 1 回ずつ処理されますが、 `forEach()` が終了する前に削除・再追加された場合は例外です。処理される前に削除された値に対しては `callback` は実行されません。 `forEach()` が終了する前に追加された新しい値は処理されます。

`forEach()` は `callback` 関数を `Set` オブジェクト内のそれぞれの要素に対して一回ずつ実行します。返値はありません。

例
-

### Set オブジェクトの内容を出力する

次のコードでは、`Set` オブジェクト内の各要素に対してログを出力します。


```js
function logSetElements(value1, value2, set) {
  console.log(`s[${value1}] = ${value2}`);
}

new Set(["foo", "bar", undefined]).forEach(logSetElements);

// Logs:
// "s[foo] = foo"
// "s[bar] = bar"
// "s[undefined] = undefined"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.foreach |

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

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

関連情報
----

* `Array.prototype.forEach()`
* `Map.prototype.forEach()`
空文
==

**空文** は、JavaScript 構文で文が想定されているときに、文を用意しないために使います。

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

構文
--


```js
;
```

解説
--

空文はセミコロン (`;`) で、JavaScript の構文上で文を必要とするときでも文を実行しないことを示します。

逆のふるまいとして、 JavaScript が単一文のみ許可しているのに複数の文にしたい場合には、ブロック文を使ってください。ブロック文は、いくつかの文を単一文に結合します。

例
-

### 空のループ本体

空文は、ループ文で使われることがあります。ループ本体が空である以下の例をご覧ください。


```js
const arr = [1, 2, 3];

// 配列の値をすべて 0 にする
for (let i = 0; i < arr.length; arr[i++] = 0) /\* 空文 \*/ ;

console.log(arr);
// [0, 0, 0]
```

### 意図的でない使用

空文を*意図的*に使っていることをコメントするとよいでしょう。通常のセミコロンと区別するのが難しいからです。

次の例は、おそらく意図的でない使用例です。


```js
if (condition); // 注意: この "if" は何の意味もない!
killTheUniverse(); // この関数が常に実行される!!!
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-empty-statement |

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

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

関連情報
----

* ブロック文
continue
========

**`continue`** 文は、現在のループまたはラベル付きループの現在反復処理中の文の実行を終了し、次の反復処理としてループの実行を続けます。

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

構文
--


```js
continue;
continue label;
```


`label` 省略可

その文のラベルに関連付けられた識別子。

解説
--

`break` 文と対照的に、 `continue` はループの実行を完全には終了しません。代わりに、

* `while` または `do...while` ループでは、条件式にジャンプします。
* `for` ループでは、更新式にジャンプします。
* `for...in`、`for...of`、`for await...of` ループでは、次の反復処理にジャンプします。

`continue` 文には任意でラベルを含めることができ、現在のループの代わりにラベル付きループ文の次の反復処理へジャンプすることができます。この場合、`continue` 文は、ラベル付き文の中にある必要があります。

`continue` 文は、その後にラベルがあるかどうかに関わらず、スクリプト、モジュール、関数の本体、静的初期化ブロックのそれぞれ最上位で使用することはできません。その関数やクラスがさらにループの中に含まれていた場合でもです。

例
-

### while における continue の使用

次の例では、 `while` ループで `i` の値が 3 であるときに実行される `continue` 文を持つものを示しています。よって、 `n` は 1、3、7、12 の値をとります。


```js
let i = 0;
let n = 0;

while (i < 5) {
  i++;

  if (i === 3) {
    continue;
  }

  n += i;
}
```

### ラベル付き continue の使用

次の例では、`checkIAndJ` とラベル付けされた文が、`checkJ` とラベル付けされた文を含んでいます。もし `continue` と遭遇したなら、プログラムは `checkJ` 文の先頭から継続します。`continue` と遭遇するたびに、`checkJ` の条件が false を返すまで、`checkJ` は再度反復処理します。false が返されたら、`checkIAndJ` 文の残りが完遂されます。

もし `continue` がラベル `checkIAndJ` を持っていたなら、プログラムは `checkIAndJ` 文の先頭から継続します。


```js
let i = 0;
let j = 8;

checkIAndJ: while (i < 4) {
  console.log(`i: ${i}`);
  i += 1;

  checkJ: while (j > 4) {
    console.log(`j: ${j}`);
    j -= 1;

    if (j % 2 === 0) continue checkJ;
    console.log(`${j} is odd.`);
  }
  console.log(`i = ${i}`);
  console.log(`j = ${j}`);
}
```


結果:
```

i: 0

// start checkj
j: 8
7 is odd.
j: 7
j: 6
5 is odd.
j: 5
// end checkj

i = 1
j = 4

i: 1
i = 2
j = 4

i: 2
i = 3
j = 4

i: 3
i = 4
j = 4
```

### 構文違反の continue 文

`continue` は関数の境界をまたがるループ内で使用することはできません。


```js
for (let i = 0; i < 10; i++) {
  (() => {
    continue; // SyntaxError: Illegal continue statement: no surrounding iteration statement
  })();
}
```


ラベルを参照する場合は、ラベル付きの文がその `continue` 文を含んでいなければなりません。


```js
label: for (let i = 0; i < 10; i++) {
  console.log(i);
}

for (let i = 0; i < 10; i++) {
  continue label; // SyntaxError: Undefined label 'label'
}
```


ラベル付きの文はループでなければなりません。


```js
label: {
  for (let i = 0; i < 10; i++) {
    continue label; // SyntaxError: Illegal continue statement: 'label' does not denote an iteration statement
  }
}
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-continue-statement |

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

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

関連情報
----

* `break`
* ラベル
function 宣言
===========

**`function`** 宣言は、指定された引数を使用して関数を定義します。

また、 `Function` のコンストラクターと関数式を使用して関数を定義することもできます。

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

構文
--


```js
function name(param0) {
  statements
}
function name(param0, param1) {
  statements
}
function name(param0, param1, /\* … ,\*/ paramN) {
  statements
}
```


`name`

関数の名前です。

`param` 省略可

関数に渡す引数の名前です。引数の最大数はエンジンによって異なります。

`statements` 省略可

関数の本体を構成する文です。

解説
--

関数宣言で作成された関数は `Function` オブジェクトであり、`Function` オブジェクトのすべてのプロパティ、メソッド、動作を備えています。関数の詳細については `Function` を参照してください。

関数は式を使用して作成することもできます (関数式を参照)。

既定では、関数は `undefined` を返します。他の値を返すには、関数に返す値を指定する `return` 文が必要です。

### 条件付きで作成される関数

**警告:** 厳格モードではない場合、ブロック内での関数宣言は奇妙な動きをします。ブロック内での関数宣言は、厳格モード時のみ行ってください。

関数は条件付きで宣言できます。つまり、関数文を `if` 文の中に入れ子にすることができますが、結果は実装によって一貫性がないので、このパターンを本番コードでは使用すべきではありません。条件付きの関数の作成には、代わりに関数式を使用してください。


```js
console.log(
  `'foo' name ${
 "foo" in globalThis ? "is" : "is not"
 } global. typeof foo is ${typeof foo}`,
);
if (false) {
  function foo() {
    return 1;
  }
}

// In Chrome:
// 'foo' の名前はグローバル。typeof foo は undefined
//
// In Firefox:
// 'foo' の名前はグローバル。typeof foo は undefined
//
// In Safari:
// 'foo' の名前はグローバル。typeof foo は function
```


`if` 本体が実際に実行されるかどうかにかかわらず、スコープと巻き上げの効果は変わりません。


```js
console.log(
  `'foo' name ${
 "foo" in globalThis ? "is" : "is not"
 } global. typeof foo is ${typeof foo}`,
);
if (true) {
  function foo() {
    return 1;
  }
}

// In Chrome:
// 'foo' の名前はグローバル。typeof foo は undefined
//
// In Firefox:
// 'foo' の名前はグローバル。typeof foo は undefined
//
// In Safari:
// 'foo' の名前はグローバル。typeof foo は function
```


厳格モードでは、ブロックレベルの関数宣言はそのブロックのスコープとなり、そのブロックの先頭に巻き上げられます。


```js
"use strict";

{
  foo(); // Logs "foo"
  function foo() {
    console.log("foo");
  }
}

console.log(
  `'foo' name ${
 "foo" in globalThis ? "is" : "is not"
 } global. typeof foo is ${typeof foo}`,
);
// 'foo' name is not global. typeof foo is undefined
```

### 関数宣言の巻き上げ

JavaScript の関数宣言は、それを囲む関数やグローバルスコープの先頭に巻き上げられ、関数を宣言する前に使うことができます。


```js
hoisted(); // "foo" とログ出力

function hoisted() {
  console.log("foo");
}
```


関数式は巻き上げられないことに注意してください。


```js
notHoisted(); // TypeError: notHoisted is not a function

var notHoisted = function () {
  console.log("bar");
};
```

例
-

### function の使用

以下のコードは、3 つの商品の販売個数が指定されたときに、売上の合計額を返す関数を宣言しています。


```js
function calcSales(unitsA, unitsB, unitsC) {
  return unitsA \* 79 + unitsB \* 129 + unitsC \* 699;
}
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-function-definitions |

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

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

関連情報
----

* `Function`
* 関数式
* function\* 文
* function\* 式
* アロー関数
* `GeneratorFunction`
* 非同期関数
* 非同期関数式
async function\*
================

**`async function*`** 宣言は非同期ジェネレーター関数を定義し、これは `AsyncGenerator` オブジェクトを返します。

非同期ジェネレーター関数は、`AsyncGeneratorFunction` コンストラクターや `async function*` 式の構文を使用して定義することもできます。

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

構文
--


```js
async function\* name(param0) {
  statements
}
async function\* name(param0, param1) {
  statements
}
async function\* name(param0, param1, /\* … ,\*/ paramN) {
  statements
}
```


**メモ:** 非同期ジェネレーター関数には、対応するアロー関数はありません。

### 引数

`name`

関数名です。

`param` 省略可

関数の構文上の引数名です。

`statements` 省略可

関数の本体を構成する文です。

解説
--

非同期ジェネレーター関数は、非同期関数とジェネレーター関数の機能を組み合わせたものです。関数の内部で `await` と `yield` のキーワードの両方を使うことができます。これにより、ジェネレーター関数の遅延の性質を利用しながら、`await` で人間工学的に非同期タスクを処理することができるようになります。

`function*` で宣言された通常のジェネレーター関数とは異なり、非同期ジェネレーター関数は `AsyncGenerator` オブジェクトを返します。非同期反復可能プロトコルに準拠しています。`next()` を呼び出すたびに、イテレーターの結果オブジェクトに解決する `Promise` を返します。

非同期ジェネレーターからプロミスが生成されると、イテレーターの結果のプロミスの最終的な状態は、生成されたプロミスの状態と一致します。例えば次のようになります。


```js
async function\* foo() {
  yield Promise.reject(1);
}

foo()
  .next()
  .catch((e) => console.error(e));
```


生成されたプロミスが拒否された場合、イテレーターの結果も拒否されるため、`1` がログ出力されます。非同期ジェネレーターの解決結果の `value` プロパティは、別のプロミスにはなりません。

`async function*` 宣言は、そのスコープの先頭に巻き上げされ、そのスコープ内のどこでも呼び出すことができます。

例
-

### 非同期ジェネレーター関数の宣言

非同期ジェネレーター関数は、常に結果のプロミスを生成します。それぞれの `yield` 手順が同期的であってもです。


```js
async function\* myGenerator(step) {
  await new Promise((resolve) => setTimeout(resolve, 10));
  yield 0;
  yield step;
  yield step \* 2;
}

const gen = myGenerator(2);
gen
  .next()
  .then((res) => {
    console.log(res); // { value: 0, done: false }
    return gen.next();
  })
  .then((res) => {
    console.log(res); // { value: 2, done: false }
    return gen.next();
  })
  .then((res) => {
    console.log(res); // { value: 4, done: false }
    return gen.next();
  })
  .then((res) => {
    console.log(res); // { value: undefined, done: true }
    return gen.next();
  });
```

### 非同期ジェネレーター関数を用いて一連のファイルを読み込む

この例では、Node の `fs/promises` モジュールを使用して、一連のファイルを読み、リクエストされたときだけそのコンテンツにアクセスするようにしています。


```js
async function\* readFiles(directory) {
  const files = await fs.readdir(directory);
  for (const file of files) {
    const stats = await fs.stat(file);
    if (stats.isFile()) {
      yield {
        name: file,
        content: await fs.readFile(file, "utf8"),
      };
    }
  }
}

const files = readFiles(".");
console.log((await files.next()).value);
// Possible output: { name: 'file1.txt', content: '...' }
console.log((await files.next()).value);
// Possible output: { name: 'file2.txt', content: '...' }
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-async-generator-function-definitions |

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

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

関連情報
----

* `async function*` 式
* `AsyncGeneratorFunction` オブジェクト
* イテレータープロトコル
* `GeneratorFunction` オブジェクト
* `yield`
* `yield*`
* `Function` オブジェクト
* 関数
do...while
==========

**`do...while`** 文は指定された文を、テスト条件が false に評価されるまで実行するループを作成します。条件は文を実行した後に評価されます。結果として、指定された文は少なくとも 1 回は実行されます。

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

構文
--


```js
do
  statement
while (condition);
```


`statement`

少なくとも 1 回は実行され、条件が真と評価されるたびに再実行される文。ループ内で複数の文を実行するには、それらの文をグループ化するためにブロック文 (`{ /* ... */ }`) を使ってください。

`condition`

ループを通過した後ごとに評価される式。もし `condition` が true に評価されるなら、`statement` は再度実行されます。`condition` が false に評価されるときは、制御が `do...while` に続く文へ渡ります。

メモ: `break` 文を使うと、`condition` が false と評価される前にループを停止することができます。

例
-

### `do...while` の使用

次の例では、 `do...while` ループを少なくとも 1 回は実行し、 `i` が 5 より小さいという条件を満たさなくなるまで反復します。


```js
let result = "";
let i = 0;
do {
  i += 1;
  result += `${i} `;
} while (i > 0 && i < 5);
// Despite i === 0 this will still loop as it starts off without the test

console.log(result);
```

### 条件として代入文を使用

場合によっては、条件として代入を使用することは意味があります。しかし、その場合、正しい方法と間違った方法があります。`while` のドキュメントでは、代入を条件として使用の節で、知っておくべき、そして従うべき一般的な良い実践例を示しています。

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-do-while-statement |

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

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

関連情報
----

* `while`
* `for`
* `break`
* `continue`