recursal/MDN huggingface dataset:
URIError: malformed URI sequence
================================

JavaScript の例外 "malformed URI sequence" は、 URI エンコードまたはデコードに失敗したときに発生します。

エラーメッセージ
--------


```js
URIError: The URI to be encoded contains invalid character (Edge)
URIError: malformed URI sequence (Firefox)
URIError: URI malformed (Chrome)
```

エラータイプ
------

`URIError`何がうまくいかなかったのか？
--------------

URI エンコードまたはデコードが成功しませんでした。`decodeURI` か `encodeURI`、`encodeURIComponent`、`decodeURIComponent` 関数の引数が無効のため、関数は適切にエンコード、またはデコードできませんでした。

例
-

### エンコード

エンコードは、特定の文字インスタンスをそれぞれ、文字の UTF-8 エンコーディングを表す 1 から 4 つの並びに置き換えます。高低ペアの一部ではないサロゲートをエンコードしようとした場合、次のように `URIError` が発生します。


```js
encodeURI("\uD800");
// "URIError: malformed URI sequence"

encodeURI("\uDFFF");
// "URIError: malformed URI sequence"
```


高低ペアが正しい場合の例です。


```js
encodeURI("\uD800\uDFFF");
// "%F0%90%8F%BF"
```

### デコード

デコードでは、エンコードされた URI の部分に含まれるそれぞれのエスケープシーケンスを、それを表す文字に置き換えます。そのような文字がない場合、エラーが発生します。


```js
decodeURIComponent("%E0%A4%A");
// "URIError: malformed URI sequence"
```


適切な入力を行うと、通常は次のようになります。


```js
decodeURIComponent("JavaScript\_%D1%88%D0%B5%D0%BB%D0%BB%D1%8B");
// "JavaScript\_шеллы"
```

関連項目
----

* `URIError`
* `decodeURI`
* `encodeURI`
* `encodeURIComponent`
* `decodeURIComponent`
isNaN()
=======

**`isNaN()`** 関数は引数が `NaN` (非数) かどうかを判定します。`isNaN` 関数の型強制は意外なものになる可能性があるため、他の `Number.isNaN()` を使用した方が良いかもしれません。

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

構文
--


```js
isNaN(value);
```

### 引数

`value`

テストされる値。

### 返値

渡された値が `NaN` である場合は **`true`** を返し, そうでなければ **`false`** を返します。

解説
--

### isNaN 関数の必要性

JavaScript のその他すべての値とは違い、等値性評価演算子（== と ===）を `NaN` に対して使用してその値が `NaN` であるかどうかを判定することはできません。 `NaN == NaN` と `NaN === NaN` はどちらも `false` と評価されるからです。そこで、`isNaN` が必要となります。

### NaN 値の生成条件

`NaN` の値は、算術演算の結果が*未定義*または*表現不可能*な値となった時に生成されます。こうした値が常にオーバーフロー状態を表現するとは限りません。`NaN` はプリミティブな数値が利用不可能といった、非数値を数値へと型強制した結果として生成されることもあります。

例えば、ゼロをゼロで除算した場合の結果は `NaN` になりますが、その他の数をゼロで除算した場合は異なります。

### 特殊な場合における厄介な動作

`isNaN` 関数の定義はごく初期のバージョン以降、数値ではない引数における振る舞いが分かりにくいものとなっていました。 `isNaN` 関数の引数が数値型ではない場合、その値はまず数へと型強制されます。その結果の値はその後 `NaN` かどうかがテストされます。このようにして、数値型に型強制される際に結果が NaN ではない数値となる非数値 (とりわけ型強制されると 0 や 1 の値になる空文字列や論理値プリミティブ) に対しては、予想外なことに "false" が返されます。無論、例えば空文字列は「数ではありません」。この混乱は、 "not a number" (数ではない) というこの用語が IEEE-754 浮動小数点数定義で表現された数においては特別な意味を持っていることに起因しています。この関数は、「この値を数値型に型強制した場合、IEEE-754 における 'Not A Number' という値になりますか？」という質問に答えるものとして解釈すべきです。

ECMAScript 2015 では `Number.isNaN()` 関数が存在します。`Number.isNaN(x)` は `x` が `NaN` かどうかをテストする確実な方法です。しかしながら `Number.isNaN` においても、`NaN` の意味は明確な数値的意味を持つ "not a number" のままです。`Number.isNaN` が利用できない場合、`x` が `NaN` かどうかを確実にテストする代わりの方法として `(x != x)` という式があります。この式の結果は信頼性のない `isNaN` が引き起こす誤検出の影響を受けません。

`isNaN` のポリフィルは以下のようになります (このポリフィルは `NaN` が自分自身と常に等しくならないという特徴を利用しています)。


```js
const isNaN = function (value) {
  const n = Number(value);
  return n !== n;
};
```

例
-


```js
isNaN(NaN); // true
isNaN(undefined); // true
isNaN({}); // true

isNaN(true); // false
isNaN(null); // false
isNaN(37); // false

// strings
isNaN("37"); // false: "37" は非数でない数値 37 に変換される
isNaN("37.37"); // false: "37.37" は非数でない数値 37.37 に変換される
isNaN("37,5"); // true
isNaN("123ABC"); // true: parseInt("123ABC") の結果は 123、しかし Number("123ABC") の結果は NaN
isNaN(""); // false: 空文字列は非数でない 0 に変換される
isNaN(" "); // false: 半角スペースからなる文字列は非数でない 0 に変換される

// dates
isNaN(new Date()); // false
isNaN(new Date().toString()); // true

// isNaN が信頼性に欠ける理由となる誤検出の例
isNaN("blabla"); // true: "blabla" が数値に変換される。
// 数値への変換が失敗し NaN が返される。
```

### 特殊な場合における便利な動作

`isNaN()` のふるまいを考慮した別の使用方法があります。`isNaN(x)` が `false` を返す場合、`NaN` を返すことなく算術式内で `x` を使用できます。`true` を返す場合、`x` を使用すると全ての算術式で `NaN` を返すことになります。これはつまり、JavaScript において `isNaN(x) == true` という式は、`x - 0` という式が `NaN` を返すかどうか、というケースと同等である（JavaScript では `x - 0 == NaN` は常に false を返すため、このことを確認できませんが）ということです。実際、`isNaN(x)`、`isNaN(x - 0)`、`isNaN(Number(x))`、`Number.isNaN(x - 0)`、そして `Number.isNaN(Number(x))` は常に同じ値を返し、JavaScript では `isNaN(x)` がこれらの条件を表す最も短い形式となります。

例えばこの動作を使って、ある関数への引数が算術処理可能か (数値として利用できるか) どうかをテストするのに利用し、そうでない場合は既定値などを与えるようにできます。この方法によりコンテキスト次第で値を暗黙的に変換する汎用性の高い JavaScript 関数を作成できます。

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-isnan-number |

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

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

関連情報
----

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

**`AsyncGenerator`** オブジェクトは非同期ジェネレーター関数から返されるもので、非同期反復可能プロトコルと非同期イテレータープロトコルの両方を満たすものです。

非同期ジェネレーターメソッドは、常に `Promise` オブジェクトを生成します。

`AsyncGenerator` は隠しクラスの `AsyncIterator` のサブクラスです。

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

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

`AsyncGenerator` コンストラクターはグローバルには利用できません。`AsyncGenerator` のインスタンスは、非同期ジェネレーター関数から返される必要があります。


```js
async function\* createAsyncGenerator() {
  yield await Promise.resolve(1);
  yield await Promise.resolve(2);
  yield await Promise.resolve(3);
}
const asyncGen = createAsyncGenerator();
asyncGen.next().then((res) => console.log(res.value)); // 1
asyncGen.next().then((res) => console.log(res.value)); // 2
asyncGen.next().then((res) => console.log(res.value)); // 3
```


実際、`AsyncGenerator`コンストラクターに対応するJavaScriptのエンティティはありません。非同期ジェネレーター関数によって生成されるすべてのオブジェクトによって共有されるプロトタイプオブジェクトである隠しオブジェクトがあるだけです。このオブジェクトはクラスのように見せるために `AsyncGenerator.prototype` というスタイルで呼ばれることが多いのですが、`AsyncGeneratorFunction.prototype.prototype` と呼ぶほうが適切でしょう。なぜなら `AsyncGeneratorFunction` は実際の JavaScript エンティティであるからです。

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

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

`AsyncGenerator.prototype.constructor`

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

**メモ:** `AsyncGenerator` は生成した非同期ジェネレーター関数を格納しているわけではありません。

`AsyncGenerator.prototype[@@toStringTag]`

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

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

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

`AsyncGenerator.prototype.next()`

`Promise` を返します。これは、`yield` 式で返された指定された値で解決されます。

`AsyncGenerator.prototype.return()`

ジェネレータ本体に現在の停止位置に `return` 文を挿入したかのように動作します。`try...finally` ブロックと組み合わせるとジェネレーターを終了し、クリーンアップタスクを実行することができます。

`AsyncGenerator.prototype.throw()`

ジェネレーター本体の現在の停止位置に `throw` 文が挿入されたかのように動作します。これは、ジェネレーターにエラー状態を通知し、エラーを処理するか、クリーンアップを実行して自身を終了させることができます。

例
-

### 非同期ジェネレーターの反復処理

次の例では、非同期ジェネレーターを反復処理し、時間間隔が短くなるごとに 1～6 の値をコンソールに出力しています。時刻が変わるたびにプロミスが生成されますが、それは `for await...of` ループの中で自動的に解決されることに注意してください。


```js
// 非同期タスクです。実際にはもっと有益なことを使用していることを
// 想定してください。
function delayedValue(time, value) {
  return new Promise((resolve /\*, reject\*/) => {
    setTimeout(() => resolve(value), time);
  });
}

async function\* generate() {
  yield delayedValue(2000, 1);
  yield delayedValue(100, 2);
  yield delayedValue(500, 3);
  yield delayedValue(250, 4);
  yield delayedValue(125, 5);
  yield delayedValue(50, 6);
  console.log("All done!");
}

async function main() {
  for await (const value of generate()) {
    console.log("value", value);
  }
}

main().catch((e) => console.error(e));
```

仕様書
---

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

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

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

関連情報
----

* function\*
* async function\*
* `function*` 式
* Generator Function
* Async Generator Function
* イテレーターとジェネレーター
encodeURI()
===========

**`encodeURI()`** 関数は、URI (Uniform Resource Identifier; 統一資源識別子) をエンコードし、各文字のインスタンスをそれぞれ UTF-8 符号の文字を表す 1 個から 4 個のエスケープシーケンスに置き換えます (サロゲート文字のペアのみ 4 個のエスケープシーケンスになります)。

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

構文
--
```

encodeURI(URI)
```

### 引数

`URI`

完全 URI です。

### 返値

URI (Uniform Resource Identifier) としてエンコードされた指定された文字列を表す新しい文字列です。

解説
--

`encodeURI()` 関数では、 URI において特別な意味を持つ文字 (予約文字) はエンコードされません。下記の例は URI "scheme" に含まれる可能性がある全ての箇所を示しています。特定の文字がどのように特殊な意味を表すために使われているかに注意してください。
```

http://username:password@www.example.com:80/path/to/file.php?foo=316&bar=this+has+spaces#anchor
```


したがって、 `encodeURI()` は完全な URI を表すのに必要な文字はエンコード**しません**。また、 `encodeURI()` は "unreserved marks" (予約されていないが "そのまま" URI に使用できる) 文字をエンコード**しません**。 (RFC2396 を確認してください。)

`encodeURI()` は下記**以外**の全ての文字をエスケープします。
```

エスケープされないもの:

    A-Z a-z 0-9 ; , / ? : @ & = + $ - _ . ! ~ * ' ( ) #
```

例
-

### encodeURI と encodeURIComponent

`encodeURI()` は以下のように `encodeURIComponent()` とは異なります。


```js
var set1 = ";,/?:@&=+$#"; // 予約文字
var set2 = "-\_.!~\*'()"; // 予約されていない記号
var set3 = "ABC abc 123"; // 英数字 + 空白

console.log(encodeURI(set1)); // ;,/?:@&=+$#
console.log(encodeURI(set2)); // -\_.!~\*'()
console.log(encodeURI(set3)); // ABC%20abc%20123 (空白は %20 にエンコードされる)

console.log(encodeURIComponent(set1)); // %3B%2C%2F%3F%3A%40%26%3D%2B%24%23
console.log(encodeURIComponent(set2)); // -\_.!~\*'()
console.log(encodeURIComponent(set3)); // ABC%20abc%20123 (空白は %20 にエンコードされる)
```


なお、`encodeURI()` のみでは、 HTTP の `GET` および `POST` リクエストを `XMLHttpRequest` のように適切に構成できません。なぜなら、 "`&`", "`+`", "`=`" は `GET` および `POST` リクエストにおいて特別な文字であり、それらがエンコードされないからです。 `encodeURIComponent()` の場合、それらがエンコードされます。

### 単独のサロゲート文字のエンコード

サロゲートペアになっていない 1 個のサロゲート文字をエンコードしようとすると `URIError` が発生することに注意してください。例えば、


```js
// サロゲートペアは OK
console.log(encodeURI("\uD800\uDFFF"));

// 上位サロゲートのみだと "URIError: malformed URI sequence" エラーが発生
console.log(encodeURI("\uD800"));

// 下位サロゲートのみだと "URIError: malformed URI sequence" エラーが発生
console.log(encodeURI("\uDFFF"));
```

### IPv6 のエンコード

また、 URL 記述のために最近の RFC3986 仕様に従おうとする場合、角括弧 `[]` は (IPv6 用の) 予約文字となっているため、角括弧が (ホスト名など) URL の一部を形成している場合はエンコードされていないほうがよいでしょう。そういう場合は以下のコードが役に立ちます。


```js
function fixedEncodeURI(str) {
  return encodeURI(str).replace(/%5B/g, "[").replace(/%5D/g, "]");
}
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-encodeuri-uri |

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

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

関連情報
----

* `decodeURI()`
* `encodeURIComponent()`
* `decodeURIComponent()`
undefined
=========

グローバルの **`undefined`** プロパティはプリミティブ値の `undefined` を表します。これは JavaScript におけるプリミティブ型の一つです。

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

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

構文
--


```js
undefined;
```

解説
--

`undefined` は、*グローバルオブジェクト*のプロパティです。すなわちグローバルスコープ内の変数です。 `undefined` の初期値はプリミティブ値である `undefined` です。

最近のブラウザー (JavaScript 1.8.5 / Firefox 4 以降) での `undefined` は、 ECMAScript 5 仕様により、設定不可、書込不可のプロパティとなります。 (そうでない場合でも、上書きは避けてください。)

まだ値が代入されていない変数は `undefined` 型となります。評価しようとしている変数に値が代入されていない場合、メソッドや文も `undefined` を返します。値を `return` しない関数も `undefined` を返します。

**メモ:** グローバルスコープ以外のスコープでは `undefined` を識別子 (変数名) として使うことができますが (`undefined` は予約語でないため)、コードの管理やデバッグが困難になるためおすすめできません。


```js
//こんなことはしないこと！

// "foo string" をログ出力する
(function () {
  var undefined = "foo";
  console.log(undefined, typeof undefined);
})();

// "foo string" をログ出力する
(function (undefined) {
  console.log(undefined, typeof undefined);
})("foo");
```


例
-

### 厳密等価と undefined

`undefined` と厳密等価・非等価演算子を使って、変数に値があるか調べることができます。次のコードでは、変数 `x` が定義されていないため、 `if` 文は true に評価されます。


```js
var x;
if (x === undefined) {
  // ここの文は実行される
} else {
  // ここの文は実行されない
}
```


**メモ:** ここでは、標準の等価演算子ではなく厳密等価演算子を使わないといけません。厳密等価演算子とは違い、 `x == undefined` は、 `x` が `null` であるかどうかもチェックするからです。 `null` は `undefined` と等しくありません。

詳しくは、比較演算子を参照してください。

### typeof 演算子と undefined

代わりに、 `typeof` を使用することができます。


```js
var x;
if (typeof x === "undefined") {
  // ここの文は実行される
}
```


`typeof` を使う理由の一つとして、こちらは変数が宣言されていなくてもエラーにはなりません。


```js
// 直前まで x は宣言されていない
if (typeof x === "undefined") {
  // エラーなしで true と評価される
  // ここの文は実行される
}

if (x === undefined) {
  // ReferenceError が発生
}
```


しかし、もう一つの選択肢があります。 JavaScript は静的にスコープされた言語なので、変数が宣言されているかどうかを知るには、それが含まれるコンテキストで宣言されているかどうかを見ることで読み取ることができます。

グローバルスコープはグローバルオブジェクトに結びつけられているので、グローバルコンテキストに変数が存在するかどうかのチェックは、*グローバルオブジェクト*にプロパティが存在することを、 `in` 演算子を使用してチェックすることで行うことができます。


```js
if ("x" in window) {
  // x がグローバルに定義されている場合のみ、ここの文を実行
}
```

### void 演算子と undefined

3 つ目の方法として、`void` 演算子があります。


```js
var x;
if (x === void 0) {
  // ここの文は実行される
}

// 直前まで y は宣言されていない
if (y === void 0) {
  // ReferenceError: y is not defined が発生
}
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-undefined |

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

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

関連情報
----

* JavaScript の プリミティブ型
* `null`
WeakMap
=======

**`WeakMap`** オブジェクトは、キーが弱く参照されるキーと値の組のコレクションです。キーはオブジェクトでなければならず、値は任意の値を取ることができます。

`WeakMap` については、 WeakMap オブジェクトのガイド (キー付きコレクション内) でより詳しく解説しています。

解説
--

WeakMap のキーは `Object` に限ります。プリミティブ型 はキーとして使えません（例えば `Symbol` は `WeakMap` のキーとして使えません）。

### なぜ *Weak*Map なのか?

map API は、4 つの API メソッドから共有される 2 つの配列 (1 つはキー用、もう 1 つは値用) を用いることで、JavaScript で実装*できます*。このマップに要素を設定すると、それぞれの配列の最後に同時にキーと値を追加することになります。その結果、両方の配列でキーと値のインデックスは対応がとれています。マップから値を取得するには、すべてのキーを操作して一致するものを見つけ、見つかったキーのインデックスを使用して値の配列から対応する値を取り出します。

そうした実装では、主に 2 つの不都合が生じることとなります。

1. 第一に、設定や探索の計算量が `O(n)` となること (*n* はマップ中におけるキーの数) で、どちらの操作も一致する値を見つけるためにキーのリストを反復しなければならないからです。
2. 第二の不都合は、配列が各キーと各値への参照を無期限に維持することを保証しているため、メモリリークが発生することです。これらの参照は、オブジェクトへの他の参照がない場合でも、キーがガベージコレクションされるのを防ぎます。これにより、対応する値がガベージコレクションされるのを防ぐことにもなります。

これに対して、ネイティブの `WeakMap` では、キーとなるオブジェクトに対しては"弱い"参照が保持されます。これにより、キーとなったオブジェクトへの参照が他に存在しない場合に、そのオブジェクトはガベージコレクションの対象に含まれるようになります。ネイティブの WeakMap はキーとそのキーに関する情報をマッピングする場合に、キーがガベージコレクションされていないときにだけ意味があるため特に有用な構造です。

**弱い参照を用いるため、`WeakMap` のキーは列挙できません。** キーの一覧を取得するメソッドは存在しません。もし、可能であれば、キーの一覧はガベージコレクションに依存することになり、非決定性が生まれます。キーの一覧が必要な場合は、`Map`を使うことになります。

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

`WeakMap()`

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

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

`WeakMap.prototype.delete(key)`

`key` に関連した値を削除します。その後 `WeakMap.prototype.has(key)` は `false` を返します。

`WeakMap.prototype.get(key)`

`key` に関連した値を返します。見つからない場合、`undefined` を返します。

`WeakMap.prototype.has(key)`

`WeakMap` オブジェクト内に `key` に関連した値があるかどうか示す Boolean を返します。

`WeakMap.prototype.set(key, value)`

`WeakMap` オブジェクト内に `key` に対する値を設定し、`WeakMap` オブジェクトを返します。

例
-

### WeakMap の使用


```js
const wm1 = new WeakMap(),
  wm2 = new WeakMap(),
  wm3 = new WeakMap();
const o1 = {},
  o2 = function () {},
  o3 = window;

wm1.set(o1, 37);
wm1.set(o2, "azerty");
wm2.set(o1, o2); // 値は（オブジェクトまたは関数を含む）何であってもかまいません
wm2.set(o3, undefined);
wm2.set(wm1, wm2); // キーも値もどんなオブジェクトでもかまいません。 WeakMap であってもよいのです！

wm1.get(o2); // "azerty"
wm2.get(o2); // wm2 には o2 に関連付けられた値が無い為、undefined が返ってきます
wm2.get(o3); // 値が undefined と関連付けられている為、undefined が返ってきます

wm1.has(o2); // true
wm2.has(o2); // false
wm2.has(o3); // true (値が関連付けられているならば、たとえ値が 'undefined' であっても true となります)

wm3.set(o1, 37);
wm3.get(o1); // 37

wm1.has(o1); // true
wm1.delete(o1);
wm1.has(o1); // false
```

### .clear() メソッドを持つ WeakMap 風のクラスの実装


```js
class ClearableWeakMap {
  constructor(init) {
    this._wm = new WeakMap(init);
  }
  clear() {
    this._wm = new WeakMap();
  }
  delete(k) {
    return this._wm.delete(k);
  }
  get(k) {
    return this._wm.get(k);
  }
  has(k) {
    return this._wm.has(k);
  }
  set(k, v) {
    this._wm.set(k, v);
    return this;
  }
}
```

仕様書
---

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

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

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

関連情報
----

* JavaScript ガイド内の `WeakMap`
* Hiding Implementation Details with ECMAScript 6 WeakMaps
* `Map`
* `Set`
* `WeakSet`
parseFloat()
============

**`parseFloat()`** 関数は、引数を (必要に応じてまず文字列に変換してから) 解釈し、浮動小数点値を返します。

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

構文
--
```

parseFloat(string)
```

### 引数

`string`

解釈する値。この引数が文字列でない場合、抽象操作 `ToString` を用いて文字列に変換されます。この引数では先頭のホワイトスペースは無視されます。

### 返値

指定された `string` を解釈した浮動小数点値です。

または、最初のホワイトスペース以外の文字が数値に変換できなかった場合は `NaN` です。

解説
--

`parseFloat` は最上位関数であり、どのオブジェクトのメソッドでもありません。

* `parseFloat` が正の符号 (`+`)、負の符号 (`-` U+002D HYPHEN-MINUS)、数値 (`0`–`9`)、小数点 (`.`)、指数記号 (`e` または `E`) 以外の文字に遭遇したら、その文字の前までの値を返し、無効な文字とそれ以降の文字を無視します。
* *2 番目*の小数点に遭遇した場合も、解析を停止します (その位置より前までの文字は解析されます)。
* 引数にある前後の空白は無視されます。
* 引数の最初の文字が数値に変換できない場合 (上記のいずれでもない場合), `parseFloat` は `NaN` を返します。
* `parseFloat` は `Infinity` を解析し、返すことができます。
* `parseFloat` は `BigInt` の構文を `Numbers` に変換し、精度は下がります。これは最後の `n` の文字が破棄されるからです。

より厳密な構文解析には `Number(value)` を検討してください。これは、引数のどこかに無効な文字があると `NaN` に変換します。

`parseFloat` は `toString` または `valueOf` メソッドが定義されているオブジェクトを解析することもできます。返値は `parseFloat` がこれらのメソッドの返値で呼び出された場合と同じです。

例
-

### 数値を返す `parseFloat`

以下の例はすべて `3.14` を返します。


```js
parseFloat(3.14);
parseFloat("3.14");
parseFloat(" 3.14 ");
parseFloat("314e-2");
parseFloat("0.0314E+2");
parseFloat("3.14some non-digit characters");
parseFloat({
  toString: function () {
    return "3.14";
  },
});
```

### `NaN` を返す `parseFloat`

以下の例は `NaN` を返します。


```js
parseFloat("FF2");
```

### `parseFloat` と `BigInt`

以下の例はどちらも `900719925474099300` を返します。 float として表現できないほど整数が大きいので、精度が失われます。


```js
parseFloat(900719925474099267n);
parseFloat("900719925474099267n");
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-parsefloat-string |

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

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

関連情報
----

* `parseInt()`
* `Number.parseFloat()`
* `Number.parseInt()`
* `Number.toFixed()`
* `isNaN()`
unescape()
==========

**警告:** `unescape()` は厳密には (「ウェブ標準から削除された」という意味では) 非推奨になっていませんが、 ECMA-262 標準の Annex B において定義されており、導入部で次のように位置付けられています。

> 
> 
>  … この附属書で規定されているすべての言語機能および動作は、1 つ以上の望ましくない特性を有しており、古い使用例がない場合には，この仕様から削除される。 …
>  … プログラマーは、新しい ECMAScript コードを書く際に、これらの機能や動作の存在を利用したり、仮定したりしてはいけない。 …
>  
> 
> 
> 

**`unescape()`** 関数は 16 進数エスケープシーケンスを、それが表す文字列に置換します。エスケープシーケンスは `escape` などの関数によって生成されます。通常は `decodeURI` または `decodeURIComponent` が `unescape` よりも推奨されます。

**メモ:** URI のデコードに `unescape` を使用しないでください。代わりに `decodeURI` を使用してください。

構文
--


```js
unescape(str);
```

### 引数

`str`

デコードされる文字列。

### 返値

特定の文字のエスケープが解除された新しい文字列です。

解説
--

`unescape` 関数は*グローバルオブジェクト*のプロパティです。

例
-

### unescape の使用


```js
unescape("abc123"); // "abc123"
unescape("%E4%F6%FC"); // "äöü"
unescape("%u0107"); // "ć"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-unescape-string |

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

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

関連情報
----

* `unescape` のポリフィル (`core-js`)
* `decodeURI`
* `decodeURIComponent`
* `escape`
decodeURI()
===========

**`decodeURI()`** 関数は、`encodeURI()` 関数あるいは同様のルーチンによって事前に作成された URI (Uniform Resource Identifier; 統一資源識別子) をデコードします。

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

構文
--
```

decodeURI(encodedURI)
```

### 引数

`encodedURI`

完全にエンコードされた URI。

### 返値

与えられたエンコードされた統一資源識別子 (URI) のエンコードされていないバージョンを表す新しい文字列。

### 例外

`encodedURI` が無効な文字の並びを含む場合、`URIError` ("malformed URI sequence") 例外が発生します。

解説
--

エンコードされた URI のエスケープシーケンスを、それぞれが表す文字に置き換えます。ただし、`encodeURI` によって生成されないエスケープシーケンスはデコードしません。また、"`#`" の文字はエスケープシーケンスからデコードされません。

使用例
---

### キリル文字の URL をデコード


```js
decodeURI(
  "https://developer.mozilla.org/ru/docs/JavaScript\_%D1%88%D0%B5%D0%BB%D0%BB%D1%8B",
);
// "https://developer.mozilla.org/ru/docs/JavaScript\_шеллы"
```

### エラーの捕捉
```

try {
  var a = decodeURI('%E0%A4%A');
} catch(e) {
  console.error(e);
}

// URIError: malformed URI sequence
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-decodeuri-encodeduri |

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

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

関連情報
----

* `decodeURIComponent()`
* `encodeURI()`
* `encodeURIComponent()`
EvalError
=========

**`EvalError`** オブジェクトは、グローバルの `eval()` 関数に関するエラーを示します。この例外はもう JavaScript からは発生しなくなっていますが、互換性のために `EvalError` オブジェクトが残っています。

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

`EvalError()`

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

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

`EvalError.prototype.message`

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

`EvalError.prototype.name`

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

`EvalError.prototype.fileName`

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

`EvalError.prototype.lineNumber`

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

`EvalError.prototype.columnNumber`

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

`EvalError.prototype.stack`

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

例
-

`EvalError` は現在の ECMAScript 仕様書では使われておらず、このためランタイムからも投げられません。しかしオブジェクト自体は、以前の仕様書との後方互換性のために残っています。

### EvalError の生成


```js
try {
  throw new EvalError("Hello", "someFile.js", 10);
} catch (e) {
  console.log(e instanceof EvalError); // true
  console.log(e.message); // "Hello"
  console.log(e.name); // "EvalError"
  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-evalerror |

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

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

関連情報
----

* `Error`
* `eval()`
AggregateError
==============

**`AggregateError`** オブジェクトは、複数のエラーを 1 つのエラーにまとめる必要があるときのエラーを表します。これは一つの操作で複数のエラーを報告する必要があるときに発生します。例えば `Promise.any()` において、渡されたすべてのプロミスが拒否された場合などです。

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

`AggregateError()`

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

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

`AggregateError.prototype.message`

エラーメッセージで、既定値は `""` です。

`AggregateError.prototype.name`

エラー名で、既定値は `AggregateError` です。

`AggregateError`: `errors`

`AggregateError` のインスタンスが作成された反復可能オブジェクトを本質的に反映した配列です。例えば、 `AggregateError` が `AggregateError()` コンストラクターを用いて生成された場合、最初の引数として渡された反復可能オブジェクトから生成される配列になります。

例
-

### AggregateError の捕捉


```js
Promise.any([Promise.reject(new Error("some error"))]).catch((e) => {
  console.log(e instanceof AggregateError); // true
  console.log(e.message); // "All Promises rejected"
  console.log(e.name); // "AggregateError"
  console.log(e.errors); // [ Error: "some error" ]
});
```

### AggregateError の生成


```js
try {
  throw new AggregateError([new Error("some error")], "Hello");
} catch (e) {
  console.log(e instanceof AggregateError); // true
  console.log(e.message); // "Hello"
  console.log(e.name); // "AggregateError"
  console.log(e.errors); // [ Error: "some error" ]
}
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-aggregate-error-objects |

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

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

関連情報
----

* `AggregateError` の `core-js` におけるポリフィル
* `Error`
* `Promise.any`
isFinite()
==========

グローバル関数 **`isFinite()`** は渡された値が有限数かどうかを判定します。必要に応じて、引数はまず数値へと変換されます。

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

構文
--
```

isFinite(testValue)
```

### 引数

`testValue`

有限性の評価を行いたい値。

### 返値

正または負の `Infinity` か `NaN` か `undefined` の場合は **`false`** です。それ以外の場合は **`true`** です。

解説
--

`isFinite` はグローバルオブジェクトの関数プロパティです。

この関数を使用すると、ある数値が有限数かどうかを判定できます。 `isFinite` 関数はその引数内の数値を調査します。この関数は、引数が `NaN`、正の無限大、負の無限大のいずれかの場合に `false` を返し、それ以外は `true` を返します。

例
-

### isFinite の使用


```js
isFinite(Infinity); // false
isFinite(NaN); // false
isFinite(-Infinity); // false

isFinite(0); // true
isFinite(2e64); // true
isFinite(910); // true

isFinite(null); // true が返される、より堅牢性の高い
// Number.isFinite(null) では false となる

isFinite("0"); // true が返される、より堅牢性の高い
// Number.isFinite("0") では false となる
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-isfinite-number |

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

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

関連情報
----

* `Number.isFinite()`
* `Number.NaN`
* `Number.POSITIVE_INFINITY`
* `Number.NEGATIVE_INFINITY`