recursal/MDN huggingface dataset:
Math.floor()
============

**`Math.floor()`** 関数は与えられた数値以下の最大の整数を返します。

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

構文
--
```

Math.floor(x)
```

### 引数

`x`

数値です。

### 返値

指定された数値以下の最大の整数を表す数値です。

解説
--

`floor()` は `Math` オブジェクトの静的なメソッドなので、自ら生成した `Math` オブジェクトのメソッドとしてではなく、常に、`Math.floor()` として使用するようにしてください (`Math` のコンストラクターはありません)。

**メモ:** `Math.floor(null)` は `NaN` ではなく 0 を返します。

例
-

### Math.floor() の使用


```js
Math.floor(45.95); // 45
Math.floor(45.05); // 45
Math.floor(4); // 4
Math.floor(-45.05); // -46
Math.floor(-45.95); // -46
```

### 十進数の丸め


```js
/\*\*
 \* Decimal adjustment of a number.
 \*
 \* @param {String} type The type of adjustment.
 \* @param {Number} value The number.
 \* @param {Integer} exp The exponent (the 10 logarithm of the adjustment base).
 \* @returns {Number} The adjusted value.
 \*/
function decimalAdjust(type, value, exp) {
  // If the exp is undefined or zero...
  if (typeof exp === "undefined" || +exp === 0) {
    return Math[type](value);
  }
  value = +value;
  exp = +exp;
  // If the value is not a number or the exp is not an integer...
  if (isNaN(value) || !(typeof exp === "number" && exp % 1 === 0)) {
    return NaN;
  }
  // Shift
  value = value.toString().split("e");
  value = Math[type](+(value[0] + "e" + (value[1] ? +value[1] - exp : -exp)));
  // Shift back
  value = value.toString().split("e");
  return +(value[0] + "e" + (value[1] ? +value[1] + exp : exp));
}

// Decimal round
const round10 = (value, exp) => decimalAdjust("round", value, exp);
// Decimal floor
const floor10 = (value, exp) => decimalAdjust("floor", value, exp);
// Decimal ceil
const ceil10 = (value, exp) => decimalAdjust("ceil", value, exp);

// Round
round10(55.55, -1); // 55.6
round10(55.549, -1); // 55.5
round10(55, 1); // 60
round10(54.9, 1); // 50
round10(-55.55, -1); // -55.5
round10(-55.551, -1); // -55.6
round10(-55, 1); // -50
round10(-55.1, 1); // -60
// Floor
floor10(55.59, -1); // 55.5
floor10(59, 1); // 50
floor10(-55.51, -1); // -55.6
floor10(-51, 1); // -60
// Ceil
ceil10(55.51, -1); // 55.6
ceil10(51, 1); // 60
ceil10(-55.59, -1); // -55.5
ceil10(-59, 1); // -50
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.floor |

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

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

関連情報
----

* `Math.abs()`
* `Math.ceil()`
* `Math.round()`
* `Math.sign()`
* `Math.trunc()`
Math.tanh()
===========

**`Math.tanh()`** 関数は、引数として与えた数のハイパーボリックタンジェントを返します。すなわち



tanh
x
=

sinh
x

cosh
x

=

e
x

-

e

-
x


e
x

+

e

-
x

=

e

2
x

-
1

e

2
x

+
1

\tanh x = \frac{\sinh x}{\cosh x} = \frac {e^x - e^{-x}} {e^x + e^{-x}} = \frac{e^{2x} - 1}{e^{2x}+1}

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

構文
--
```

Math.tanh(x)
```

### 引数

`x`

数値。

### 返値

指定された数値のハイパーボリックタンジェントです。

解説
--

`tanh()` は `Math` の静的メソッドであるため、生成した `Math` オブジェクトのメソッドとしてではなく、常に `Math.tanh()` として使用するようにしてください (`Math` はコンストラクターではありません)。

ポリフィル
-----

`Math.exp()` 関数の助けを借りて、エミュレートできます。:


```js
Math.tanh =
  Math.tanh ||
  function (x) {
    var a = Math.exp(+x),
      b = Math.exp(-x);
    return a == Infinity ? 1 : b == Infinity ? -1 : (a - b) / (a + b);
  };
```

例
-

### Math.tanh() の使用


```js
Math.tanh(0); // 0
Math.tanh(Infinity); // 1
Math.tanh(1); // 0.7615941559557649
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.tanh |

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

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

関連情報
----

* `Math.acosh()`
* `Math.asinh()`
* `Math.atanh()`
* `Math.cosh()`
* `Math.sinh()`
Math.LN2
========

**`Math.LN2`** プロパティは 2 の自然対数、およそ 0.693 を表します。


Math.LN2

=
ln
(
2
)
≈
0.693

\mathtt{\mi{Math.LN2}} = \ln(2) \approx 0.693

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

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

解説
--

`LN2` は `Math` オブジェクトの静的プロパティなので、 `Math` オブジェクトを生成してプロパティとして使用するのではなく、常に `Math.LN2` として使用するようにしてください (`Math` はコンストラクターではありません)。

例
-

### Math.LN2 の使用

以下の関数は、2 の自然対数を返します。


```js
function getNatLog2() {
  return Math.LN2;
}

getNatLog2(); // 0.6931471805599453
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.ln2 |

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

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

関連情報
----

* `Math.exp()`
* `Math.log()`
* `Math.log2()`
FinalizationRegistry() コンストラクター
===============================

**`FinalizationRegistry`** コンストラクターは、指定されたコールバックを使用する `FinalizationRegistry` オブジェクトを生成します。

構文
--
```

new FinalizationRegistry([callback]);
```

### 引数

`callback` 省略可

レジストリが使用するコールバック関数です。指定された場合、関数である必要があります。

例
-

### 新しいレジストリの生成

コールバックを渡してレジストリを生成します。


```js
const registry = new FinalizationRegistry((heldValue) => {
  // ....
});
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-finalization-registry-constructor |

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

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

関連情報
----

* `FinalizationRegistry`
FinalizationRegistry.prototype.unregister()
===========================================

`unregister` は対象のオブジェクトを `FinalizationRegistry` インスタンスから登録解除します。

構文
--
```

registry.unregister(unregisterToken);
```

### 引数

`unregisterToken`

対象オブジェクトを登録したときに `register` メソッドで使用したトークンです。

### 返値

`undefined` です。

注
-

対象オブジェクトの回収が完了すると、レジストリに登録された状態ではなくなります。クリーンアップコールバックですべてに `unregister` を行う必要はありません。クリーンアップコールバックを受信しておらず、クリーンアップコールバックを受信する必要がなくなった場合にのみ `unregister` を呼び出してください。

例
-

### unregister の使用

この例では、登録解除トークンとして同じオブジェクトを使用して対象のオブジェクトを登録し、その後、 `unregister` を介して対象のオブジェクトの登録を解除します。


```js
class Thingy {
  #cleanup = (label) => {
    // ^^^^^−−−−− held value
    console.error(
      `The \`release\` method was never called for the object with the label "${label}"`,
    );
  };
  #registry = new FinalizationRegistry(this.#cleanup);

  /\*\*
 \* Constructs a `Thingy` instance. Be sure to call `release` when you're done with it.
 \*
 \* @param label A label for the `Thingy`.
 \*/
  constructor(label) {
    // vvvvv−−−−− held value
    this.#registry.register(this, label, this);
    // target −−−−−^^^^ ^^^^−−−−− unregister token
  }

  /\*\*
 \* Releases resources held by this `Thingy` instance.
 \*/
  release() {
    this.#registry.unregister(this);
    // ^^^^−−−−− unregister token
  }
}
```


この例では、登録解除トークンとして別のオブジェクトを使用して対象のオブジェクトを登録しています。


```js
 {
    // ^^^^−−−−− held value
        console.error(
            `The \`release\` method was never called for the \`Thingy\` for the file "${file.name}"`
        );
    };
    #registry = new FinalizationRegistry(this.#cleanup);

    /\*\*
 \* Constructs a `Thingy` instance for the given file. Be sure to call `release` when you're done with it.
 \*
 \* @param filename The name of the file.
 \*/
    constructor(filename) {
        this.#file = File.open(filename);
        // vvvvv−−−−− held value
        this.#registry.register(this, label, this.#file);
        // target −−−−−^^^^ ^^^^^^^^^^−−−−− unregister token
    }

    /\*\*
 \* Releases resources held by this `Thingy` instance.
 \*/
    release() {
        if (this.#file) {
            this.#registry.unregister(this.#file);
            // ^^^^^^^^^^−−−−− unregister token
            File.close(this.#file);
            this.#file = null;
        }
    }
}
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-finalization-registry.prototype.unregister |

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

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

関連情報
----

* `FinalizationRegistry`
FinalizationRegistry.prototype.register()
=========================================

`register()` メソッドはオブジェクトを `FinalizationRegistry` インスタンスへ登録し、オブジェクトがガベージコレクションで回収された場合、レジストリのコールバックが呼び出されるようになります。

構文
--
```

registry.register(target, heldValue, [unregisterToken]);
```

### 引数

`target`

登録する対象オブジェクトです。

`heldValue`

このオブジェクトのためにファイナライザーへ渡す値です。これは `target` オブジェクトにすることはできません。

`unregisterToken` 省略可

のちに対象オブジェクトを登録解除するために `unregister` メソッドと共に使用するトークンです。提供された場合 (かつ `undefined` ではない場合)、これはオブジェクトである必要があります。提供されなかった場合は、対象を登録解除することはできません。

### 返値

`undefined` です。

注
-

重要な注意点については、 `FinalizationRegistry` ページの可能な限り避けるとクリーンアップコールバックに関する注意事項の部分を参照してください。

例
-

### register の使用

次の例は `target` で参照される対象オブジェクトを保持値 `"some value"` で登録し、対象オブジェクト自身を登録解除トークンとして渡します。


```js
registry.register(target, "some value", target);
```


次の例は `target` で参照される対象オブジェクトを他のオブジェクトを保持値として登録し、登録解除トークンを渡していません (すなわち `target` は登録解除できません)。


```js
registry.register(target, { useful: "info about target" });
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-finalization-registry.prototype.register |

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

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

関連情報
----

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

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

なお、 `AsyncGeneratorFunction` はグローバルオブジェクトではありません。 以下のコードを評価することで得られます。


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


`AsyncGeneratorFunction()` コンストラクターは直接使用することを意図しておらず、`Function()` の説明で述べた注意事項はすべて `AsyncGeneratorFunction()` にも当てはまります。

構文
--


```js
new AsyncGeneratorFunction(functionBody)
new AsyncGeneratorFunction(arg0, functionBody)
new AsyncGeneratorFunction(arg0, arg1, functionBody)
new AsyncGeneratorFunction(arg0, arg1, /\* …, \*/ argN, functionBody)

AsyncGeneratorFunction(functionBody)
AsyncGeneratorFunction(arg0, functionBody)
AsyncGeneratorFunction(arg0, arg1, functionBody)
AsyncGeneratorFunction(arg0, arg1, /\* …, \*/ argN, functionBody)
```


**メモ:** `AsyncGeneratorFunction()` は `new` があってもなくても呼び出すことができます。どちらも新しい `AsyncGeneratorFunction` インスタンスを生成します。

### 引数

`Function()` を参照してください。

例
-

### コンストラクターの使用

次の例では、`AsyncGeneratorFunction` コンストラクターを使用して非同期ジェネレータ関数を作成します。


```js
const AsyncGeneratorFunction = async function\* () {}.constructor;
const createAsyncGenerator = new AsyncGeneratorFunction("a", "yield a \* 2");
const asyncGen = createAsyncGenerator(10);
asyncGen.next().then((res) => console.log(res.value)); // 20
```

仕様書
---

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

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

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

関連情報
----

* `async function*` 宣言
* `async function*` 式
* `Function()` コンストラクター
* イテレーターとジェネレーター
* 関数
WeakSet.prototype.delete()
==========================

**`delete()`** メソッドは、`WeakSet` オブジェクトから指定された要素を取り除きます。

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

構文
--
```

ws.delete(value);
```

### 引数

`value`

必須。 `WeakSet` オブジェクトから取り除くオブジェクトです。

### 返値

`WeakSet` オブジェクトの中の要素が正常に削除された場合は `true` を返します。 `value` が `WeakSet` の中で見つからなかったり、 `value` がオブジェクトではなかった場合は `false` を返します。

例
-

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


```js
var ws = new WeakSet();
var obj = {};

ws.add(window);

ws.delete(obj); // false を返します。削除する obj が見つかりません。
ws.delete(window); // true を返します。正常に削除されます。

ws.has(window); // false を返します。 window はもう WeakSet の中にないからです。
```

仕様書
---

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

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

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

関連情報
----

* `WeakSet`
* `WeakSet.prototype.clear()`
WeakSet.prototype.has()
=======================

**`has()`** メソッドは、特定の値をもつ要素が `WeakSet` オブジェクト内に存在するかどうかを示す真偽値を返します。

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

構文
--
```

ws.has(value);
```

### 引数

`value`

`WeakSet` オブジェクトに存在するかテストする値です。

### 返値

Boolean

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

例
-

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


```js
var ws = new WeakSet();
var obj = {};
ws.add(window);

mySet.has(window); // returns true
mySet.has(obj); // returns false
```

仕様書
---

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

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

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

関連情報
----

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

**`add()`** メソッドは、新しい要素を `WeakSet` オブジェクトの最後に追加します。

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

構文
--
```

ws.add(value);
```

### 引数

`value`

必須。 `WeakSet` コレクションに追加する要素の値です。

### 返値

`WeakSet` オブジェクトです。

例
-

### add() の使用


```js
var ws = new WeakSet();

ws.add(window); //window オブジェクトを WeakSet へ追加

ws.has(window); // true

// WeakSet は引数としてオブジェクトのみを取ります。
ws.add(1);
// 結果は "TypeError: Invalid value used in weak set" (Chrome)
// "TypeError: 1 is not a non-null object" (Firefox)
```

仕様書
---

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

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

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

関連情報
----

* `WeakSet`
* `WeakSet.prototype.delete()`
* `WeakSet.prototype.has()`
WeakSet() コンストラクター
==================

**`WeakSet`** コンストラクターで、 `WeakSet` オブジェクトを生成し、これに弱い参照で*オブジェクト*をコレクションで保持することができます。

構文
--
```

new WeakSet([iterable]);
```

### 引数

*iterable*

反復可能オブジェクトが渡された場合、すべての要素が新しい `WeakSet` に追加されます。 null は undefined として扱われます。

例
-

### WeakSet オブジェクトの使用


```js
var ws = new WeakSet();
var foo = {};
var bar = {};

ws.add(foo);
ws.add(bar);

ws.has(foo); // true
ws.has(bar); // true

ws.delete(foo); // foo を set から削除
ws.has(foo); // false, foo は削除済み
ws.has(bar); // true, bar は残っている
```


`foo !== bar` であることに注意してください。これらは似たオブジェクトですが、***まったく同じオブジェクト**ではありません*。したがって、両方のオブジェクトが set に追加されます。

仕様書
---

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

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

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

関連情報
----

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

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

構文
--
```

new ReferenceError([message[, fileName[, lineNumber]]])
```

### 引数

`message` 省略可

人間が読むためのエラーの説明です。

`fileName` 省略可

例外が発生したコードを含むファイルの名前です。

`lineNumber` 省略可

例外が発生したコードの行番号です。

例
-

### 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-nativeerror-constructors |

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

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

関連情報
----

* `Error`
Promise.allSettled()
====================

**`Promise.allSettled()`** は静的メソッドで、入力としてプロミスの反復可能オブジェクトを受け取り、単一の `Promise` を返します。この返されたプロミスは、入力のすべてのプロミスが決定したとき（空の反復可能オブジェクトが渡された場合を含む）に履行され、各プロミスの結果を記述するオブジェクトの配列が返されます。

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

構文
--


```js
Promise.allSettled(iterable)
```

### 引数

`iterable`

プロミスの反復可能オブジェクト（`Array` など）です。

### 返値

次のような `Promise` です。

* *反復可能*オブジェクトが空であった場合は、**履行済み**になります。
* 渡された*反復可能*オブジェクトのすべてのプロミスが（履行または拒否に）決定したとき、**非同期に履行されます**。履行されたプロミスの値はオブジェクトの配列で、それぞれが反復可能なオブジェクトの中の一つのプロミスの結果を記述しています。それぞれの成果オブジェクトには、以下のようなプロパティがあります。

`status`

文字列で、 `"fulfilled"` （履行）または `"rejected"` （拒否）をとり、そのプロミスの最終的な状態を示します。

`value`

`status` が `"fulfilled"` の場合のみ存在します。プロミスが履行された値です。

`reason`

`status` が `"rejected"` の場合のみ存在します。プロミスが拒否された理由です。

渡された反復可能オブジェクトが空でなく、待機中のプロミスを含んでいない場合、返されたプロミスは（同期ではなく）非同期に履行されます。

解説
--

`Promise.allSettled()` メソッドはプロミスの並行処理 メソッドの 1 つです。`Promise.allSettled()` は、通常、正常に完了するために互いに依存しない複数の非同期タスクがある場合、または各プロミスの結果を常に知りたい場合に使用されます。

**メモ:** 日本語の技術文書では、このメソッドが複数のプロミスを並列に処理すると説明されることがありますが、実際には複数のスレッドでプロミスが処理されるわけではないことに注意してください。詳細はプロミスの並行処理を参照してください。

それに対して、 `Promise.all()` が返すプロミスは、タスクが他にも依存している場合や、どれかが拒否されたらすぐに拒否したい場合により適しているかもしれません。

例
-

### Promise.allSettled の使用


```js
Promise.allSettled([
  Promise.resolve(33),
  new Promise((resolve) => setTimeout(() => resolve(66), 0)),
  99,
  Promise.reject(new Error("an error")),
]).then((values) => console.log(values));

// [
// { status: 'fulfilled', value: 33 },
// { status: 'fulfilled', value: 66 },
// { status: 'fulfilled', value: 99 },
// { status: 'rejected', reason: Error: an error }
// ]
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise.allsettled |

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

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

関連情報
----

* `Promise.allSettled` のポリフィル (`core-js`)
* プロミスの使用
* プロミスを使った行儀のよい非同期のプログラミング
* `Promise`
* `Promise.all()`
* `Promise.any()`
* `Promise.race()`
get Promise[@@species]
======================

**`Promise[@@species]`** アクセサープロパティは、プロミスのメソッドからの返値を構築するのに使用されるコンストラクターを返します。

**警告:** `@@species` が存在すると、任意のコードの実行が可能になり、セキュリティ上の脆弱性を生み出す可能性があります。また、特定の最適化も非常に難しくなります。エンジンの実装者はこの機能を削除するかどうか調査しています。可能であれば、この機能に頼ることは避けてください。

構文
--


```js
Promise[Symbol.species];
```

### 返値

`get @@species` が呼び出されたコンストラクター (`this`) の値です。この返値は、新しいプロミスを作成するプロミス連鎖メソッドから返値を作成するために使用されます。

解説
--

`@@species` アクセサープロパティは `Promise` オブジェクトの既定のコンストラクターを返します。サブクラスのコンストラクターはこれを上書きしてコンストラクターの割り当てを変更することができます。既定の実装では、基本的に次のようになります。


```js
// 解説のため架空の基礎実装
class Promise {
  static get [Symbol.species]() {
    return this;
  }
}
```


この多相的な実装のため、派生したサブクラスの `@@species` も既定ではコンストラクター自身を返すことになります。


```js
class SubPromise extends Promise {}
SubPromise[Symbol.species] === Promise; // true
```


プロミス連鎖メソッドである `then()`、`catch()`、`finally()` は、新しいプロミスオブジェクトを返します。これらは `this.constructor[@@species]` を介して新しいプロミスを構築するためのコンストラクターを取得します。 `this.constructor` が `undefined` の場合、または `this.constructor[@@species]` が `undefined` または `null` の場合、既定の `Promise()` コンストラクターが使用されます。それ以外の場合は、 `this.constructor[@@species]` から返されるコンストラクターが使用され、新しいプロミスオブジェクトが構築されます。

例
-

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

`Symbol.species` プロパティは、既定では `Promise` のコンストラクター関数を返します。


```js
Promise[Symbol.species]; // [Function: Promise]
```

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

`MyPromise` のような独自の `Promise` サブクラスのインスタンスでは、 `MyPromise` コンストラクターが `MyPromise` の species となります。しかし、派生クラスのメソッドで親の `Promise` オブジェクトを返すために、これをオーバーライドしたい場合があるかもしれません。


```js
class MyPromise extends Promise {
  // MyPromise の species を親の Promise コンストラクターで上書きする
  static get [Symbol.species]() {
    return Promise;
  }
}
```


既定では、プロミスメソッドはサブクラスの型を持つプロミスを返します。


```js
class MyPromise extends Promise {
  someValue = 1;
}

console.log(MyPromise.resolve(1).then(() => {}).someValue); // 1
```


`@@species` を上書きすることで、プロミスのメソッドは基底の `Promise` 型を返すことになります。


```js
class MyPromise extends Promise {
  someValue = 1;
  static get [Symbol.species]() {
    return Promise;
  }
}

console.log(MyPromise.resolve(1).then(() => {}).someValue); // undefined
```

仕様書
---

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

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

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

関連情報
----

* `Promise`
* `Symbol.species`
Promise.prototype.finally()
===========================

**`finally()`** は `Promise` のメソッドで、プロミスが決定したとき（履行されたか拒否されたかのどちらか）に呼び出される関数を準備します。直ちに同等の `Promise` オブジェクトを返すため、プロミスの他のメソッドを連鎖呼び出しすることができます。

これによって、プロミスの `then()` ハンドラーと `catch()` ハンドラーでコードが重複することを避けることができます。

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

構文
--


```js
finally(onFinally)

finally(() => {
  // プロミスの決定（履行または拒否）後に実行されるコード
})
```

### 引数

`onFinally`

`Promise` が決定したら呼び出される関数 (`Function`) です。このハンドラーは引数を取りません。

### 返値

同等の `Promise` を返します。ハンドラーがエラーを発生したり、拒否されたプロミスを返したりした場合、代わりに `finally()` が返すプロミスがその値で拒否されます。そうでなければ、ハンドラーの返す値は元のプロミスの状態に影響しません。

解説
--

プロミスが決定した後、結果に関わらず何らかの処理や後始末を行いたいなら、`finally()` メソッドは役立ちます。

`finally()` メソッドは `then(onFinally, onFinally)` の呼び出しとよく似ていますが、いくつかの点が異なります。

* 関数をインラインで作成する場合、関数を 2 度宣言するか、変数を作成するかのどちらかで、一度に渡すことができます。
* `onFinally` コールバックは一切引数を受け取りません。この用途では、拒否された理由や履行された値などを提供する必要がなく、それらを気にしないときに適しています。
* `finally()` の呼び出しは通常透過的で、元のプロミスの最終的な状態を変更することはありません。ですから例えば、
    + `Promise.resolve(2).then(() => 77, () => {})` が最終的に `77` の値で履行されるプロミスを返すのとは異なり、`Promise.resolve(2).finally(() => 77)` は最終的に `2` の値で履行されるプロミスを返します。
    + 同様に、`Promise.reject(3).then(() => {}, () => 88)` が最終的に `88` の値で履行されるプロミスを返すのとは異なり、`Promise.reject(3).finally(() => 88)` は最終的に `3` の値で拒否されるプロミスを返します。

**メモ:** `finally` コールバックの中で `throw` （あるいは拒否されたプロミスを返すこと）しても、返されたプロミスは拒否されます。例えば、 `Promise.reject(3).finally(() => { throw 99; })` と `Promise.reject(3).finally(() => Promise.reject(99))` はどちらも `99` という理由をつけて、返ってきたプロミスを拒否することになります。

`catch()` と同様に、 `finally()` は内部的に呼び出されたオブジェクトの `then` メソッドを呼び出します。もし `onFinally` が関数でない場合、 `then()` は `onFinally` を両方の引数として呼び出されます。これは `Promise.prototype.then()` にとって、有益なハンドラーが添付されないということを意味します。そうでなければ、`then()` は内部で作成された 2 つの関数で呼び出され、以下のような振る舞いをします。

**警告:** これは説明用のものであり、ポリフィルではありません。


```js
promise.then(
  (value) => Promise.resolve(onFinally()).then(() => value),
  (reason) =>
    Promise.resolve(onFinally()).then(() => {
      throw reason;
    }),
);
```


`finally()` は `then()` を呼び出すので、サブクラス化に対応しています。さらに、上記の `Promise.resolve()` の呼び出しに注目してください。実際には、 `onFinally()` の返値は `Promise.resolve()` と同じアルゴリズムで解決されますが、解決されたプロミスを構築するために使用される実際のコンストラクターはサブクラスとなります。 `finally()` はこのコンストラクターを `promise.constructor[@@species]` で取得します。

例
-

### finally() の使用


```js
let isLoading = true;

fetch(myRequest)
  .then((response) => {
    const contentType = response.headers.get("content-type");
    if (contentType && contentType.includes("application/json")) {
      return response.json();
    }
    throw new TypeError("Oops, we haven't got JSON!");
  })
  .then((json) => {
    /\* さらに JSON を処理します \*/
  })
  .catch((error) => {
    console.error(error); // この行は、 console = {} の場合など、例外が発生する可能性がある
  })
  .finally(() => {
    isLoading = false;
  });
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise.prototype.finally |

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

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

関連情報
----

* `Promise.prototype.finally` のポリフィル (`core-js`)
* `Promise`
* `Promise.prototype.then()`
* `Promise.prototype.catch()`