recursal/MDN huggingface dataset:
Number.prototype.toString()
===========================

**`toString()`** メソッドは、指定された数値を表現する文字列を返します。

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

構文
--


```js
toString()
toString(radix)
```

### 引数

`radix` 省略可

数値を表現するために使われる基数を指定する、 `2` から `36` までの整数です。既定値は 10 です。

### 返値

指定された数値を表現する文字列です。

例外
--

`RangeError`

`toString()` は、与えられた `radix` が `2` 未満、または `36` を超える場合、`RangeError` が発生します。

解説
--

`Number` オブジェクトは `Object` の `toString()` メソッドを上書きします。つまり、 `Object.prototype.toString()` を継承していません。`Number` の値では、`toString` メソッドは指定された基数でオブジェクトを表した文字列を返します。

10 より大きい基数では、 9 より大きい数をアルファベットの文字で示します。例えば、16 進表記（基数 16）では、`a` から `f` までが使われます。

`numObj` が負の場合、符号は保存されます。これは基数が 2 の場合も同様です。返される文字列は、`-` 記号で始まる数値の正の 2 進数表現であり、数値の 2 の補数では**ありません**。

`0` と `-0` はどちらも文字列表現が `"0"` となります。`Infinity` は `"Infinity"` を返し、 `NaN` は `"NaN"` を返します。

数値が整数でない場合、小数点 `.` を用いて小数点以下の位置を区切ります。科学的記数法は、基数が10で、数の大きさ（符号は無視）が 1021 以上、10-6 以下の場合に使用します。この場合、返す文字列は常に指数の符号を明示的に指定します。


```js
console.log((10 \*\* 21.5).toString()); // "3.1622776601683794e+21"
console.log((10 \*\* 21.5).toString(8)); // "526665530627250154000000"
```


この `toString()` メソッドは、`this` 値が数値プリミティブまたは `Number` ラッパーオブジェクトである必要があります。他の `this` 値に対しては、数値に変換しようとせずに `TypeError` を発生させます。

`Number` には `[@@toPrimitive]()` メソッドがないので、 `Number` *オブジェクト* がテンプレートリテラル などのように文字列を期待するコンテキストで用いられるとき、 JavaScript は `toString()` メソッドを自動的に呼び出します。しかし、数値プリミティブは `toString()` メソッドを参照して [coerced to strings] (/ja/docs/Web/JavaScript/Reference/Global\_Objects/String#string\_coercion) するのではなく、初期の `toString()` 実装と同じアルゴリズムを使用して直接変換される。


```js
Number.prototype.toString = () => "Overridden";
console.log(`${1}`); // "1"
console.log(`${new Number(1)}`); // "Overridden"
```

例
-

### toString の使用


```js
const count = 10;
console.log(count.toString()); // "10"

console.log((17).toString()); // "17"
console.log((17.2).toString()); // "17.2"

const x = 6;
console.log(x.toString(2)); // "110"
console.log((254).toString(16)); // "fe"
console.log((-10).toString(2)); // "-1010"
console.log((-0xff).toString(2)); // "-11111111"
```

### 数値文字列の基数変換

10 進数でない基数の数値を表す文字列がある場合、`parseInt()` と `toString()` を使用して別の基数に変換することが可能です。


```js
const hex = "CAFEBABE";
const bin = parseInt(hex, 16).toString(2); // "11001010111111101011101010111110"
```


精度の低下に注意してください。元となる数値文字列が大きすぎる（例えば `Number.MAX_SAFE_INTEGER` より大きい）場合、代わりに `BigInt` を使用してください。ただし、`BigInt` コンストラクタは、数値リテラルを表す文字列（`0b`, `0o`, `0x` から始まる文字列）にしか対応していません。元の基数が 2 進数、8 進数、10 進数、16 進数のいずれでもない場合は、基数変換を手で書くか、ライブラリーを使用する必要があるかもしれません。

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.prototype.tostring |

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

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

関連情報
----

* `Number.prototype.toFixed()`
* `Number.prototype.toExponential()`
* `Number.prototype.toPrecision()`
Number.prototype.toFixed()
==========================

**`toFixed()`** メソッドは、数を固定小数点表記を用いて整形します。

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

構文
--


```js
toFixed()
toFixed(digits)
```

### 引数

`digits` 省略可

小数点の後に現れる桁の数です。これは `0` 以上 `100` 以下の値です。この引数が省略されると、`0` として扱われます。

### 返値

与えられた数値を固定小数点表記を用いて表した文字列です。

例外
--

`RangeError`

`digits` が `0` 以上 `100` 以下ではない場合に発生します。

`TypeError`

このメソッドが `Number` ではないオブジェクト上で実行された場合に発生します。

解説
--

`toFixed()` メソッドは `numObj` の文字列表記を、指数表記を使用せず、小数点以下を正確に `digits` 桁として返します。必要に応じて数値は丸められ、小数部は指定された長さになるよう必要に応じて 0 で埋められます。

`numObj` の絶対値が `1e+21` 以上の場合は、このメソッドは単純に `Number.prototype.toString()` を呼び出し、指数表記での文字列を返します。`toFixed()` は `numObj` の値が有限数でない場合、`"Infinity"`、`"NaN"`、`"-Infinity"` の何れかを返します。

`toFixed()` の出力は、一部の値では `toString()` よりも正確かもしれませんが、これは `toString()` が隣の数値と区別できる程度の有効数字しか出力しないためです。例えば、次のようになります。


```js
(1000000000000000128).toString(); // '1000000000000000100'
(1000000000000000128).toFixed(0); // '1000000000000000128'
```


しかし、高すぎる `digits` の精度を選ぶと、10 進数の小数を浮動小数点で正確に表せないため、予期せぬ結果を返すことがあります。例えば次のようになります。


```js
(0.3).toFixed(50); // '0.29999999999999998889776975374843459576368331909180'
```

例
-

### toFixed() の使用


```js
const numObj = 12345.6789;

numObj.toFixed(); // '12346'。四捨五入され小数部がなくなる
numObj.toFixed(1); // '12345.7' を返す。切り上げ
numObj.toFixed(6); // '12345.678900'を返す。0 を追加
(1.23e20).toFixed(2); // '123000000000000000000.00'
(1.23e-10).toFixed(2); // '0.00'
(2.34).toFixed(1); // '2.3'
(2.35).toFixed(1); // '2.4'。切り上げ
(2.55).toFixed(1); // '2.5'
// 浮動小数点数で正確に表せず、最も近い浮動小数点数の
// 方が低いため、切り捨てられる。
(2.449999999999999999).toFixed(1); // '2.5'
// 2.45 との差が NUMBER.EPSILON 未満なので、切り上げ
// このリテラルは、実際には 2.45 と同じ数値をエンコードしている

(6.02 \* 10 \*\* 23).toFixed(50); // 6.019999999999999e+23; 巨大な数値は指数表記を使用
```

### toFixed() を負の数に使用

メンバーアクセスは単項マイナスよりも優先順位が高いので、文字列を取得するためには。負の数の式全体をグループ化する必要があります。


```js
-2.34.toFixed(1); // -2.3, a number
(-2.34).toFixed(1); // '-2.3'
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.prototype.tofixed |

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

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

関連情報
----

* `Number.prototype.toExponential()`
* `Number.prototype.toPrecision()`
* `Number.prototype.toString()`
* `Number.EPSILON`
Number.prototype.toExponential()
================================

**`toExponential()`** メソッドは `Number` オブジェクトを指数表記で表した文字列を返します。

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

構文
--


```js
toExponential()
toExponential(fractionDigits)
```

### 引数

`fractionDigits` 省略可

任意です。小数点の後の桁数を指定する整数です。既定値はその数を表すのに必要な数の桁です。

### 返値

`Number` オブジェクトを、指数表記 (小数点前は 1 桁、小数点の後は `fractionDigits` によって指定された桁で切り捨て) で表した文字列です。

### 例外

`RangeError`

`fractionDigits` が `1` 以上 `100` 以下ではない場合に発生します。

`TypeError`

このメソッドが `Number` ではないオブジェクトに対して呼び出された場合に発生します。

解説
--

`fractionDigits` 引数が省略された場合、小数点の後の桁数は、その値を特定するのに必要な桁数になります。

`toExponential` メソッドを 1 つの数値リテラル、または、指数も小数点もない数値リテラルに対して使用する場合、ドットが小数点として解釈されることを防ぐために、メソッド呼び出しに先立つドットの前に空白を置いてください。

引数 `fractionDigits` で指定された桁よりも多くの桁を持っている数の場合、その数は、`fractionDigits` の桁で表すことができる最も近い数で表されます。`toFixed()` メソッドの説明における概数表現の説明を参照してください。それは、`toExponential` メソッドにも適用されます。

例
-

### toExponential の使用


```js
const numObj = 77.1234;

console.log(numObj.toExponential()); // 7.71234e+1 と表示
console.log(numObj.toExponential(4)); // 7.7123e+1 と表示
console.log(numObj.toExponential(2)); // 7.71e+1 と表示
console.log((77.1234).toExponential()); // 7.71234e+1 と表示
console.log((77).toExponential()); // 7.7e+1 と表示
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.prototype.toexponential |

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

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

関連情報
----

* 多くのバグ修正を含んだ `Number.prototype.toExponential` のポリフィル が `core-js` で利用できます
* `Number.prototype.toFixed()`
* `Number.prototype.toPrecision()`
* `Number.prototype.toString()`
Number.NEGATIVE\_INFINITY
=========================

**`Number.NEGATIVE_INFINITY`** プロパティは負の無限大を表す値です。

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

値
-

グローバルの `Infinity` プロパティの負の値と同じです。

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

解説
--

`Number.NEGATIVE_INFINITY` の値は、数学的な無限大とは少々異なった振る舞いをします。

* `POSITIVE_INFINITY` も含む任意の正の値と、 `NEGATIVE_INFINITY` の積は `NEGATIVE_INFINITY` になります。
* `NEGATIVE_INFINITY` も含む任意の負の値と、 `NEGATIVE_INFINITY` の積は `POSITIVE_INFINITY` になります。
* 任意の正の数を `NEGATIVE_INFINITY` で割った商は、負のゼロになります（IEEE 754 で定義されているとおり）。
* 任意の負の数を `NEGATIVE_INFINITY` で割った商は、正のゼロになります（IEEE 754 で定義されているとおり）。
* 零 と `NEGATIVE_INFINITY` の積は `NaN` になります。
* NaN と `NEGATIVE_INFINITY` の積は `NaN` になります。
* `NEGATIVE_INFINITY` を `NEGATIVE_INFINITY` 以外の任意の負の値で割った商は `POSITIVE_INFINITY` になります。
* `NEGATIVE_INFINITY` を `POSITIVE_INFINITY` 以外の任意の正の値で割った商は `NEGATIVE_INFINITY` になります。
* `NEGATIVE_INFINITY` を `NEGATIVE_INFINITY` または `POSITIVE_INFINITY` のいずれかで割った商は `NaN` になります。
* `x > Number.NEGATIVE_INFINITY` は *x* の値が `NEGATIVE_INFINITY` ではない場合に true になります。

成功した場合に有限数を返す関数がエラーである状態を示すために、`Number.NEGATIVE_INFINITY` プロパティを使いたいかもしれません。しかし、そのような場合は `NaN` の方がより適しているでしょう。

`NEGATIVE_INFINITY` は `Number` の静的プロパティですので、数値のプロパティとしてではなく、常に `Number.NEGATIVE_INFINITY` として使用してください。

例
-

### NEGATIVE\_INFINITY の使用

以下の例では、変数 `smallNumber` に最小値よりも小さな値が代入されています。`if` ステートメントが実行されたとき、`smallNumber` は `-Infinity` の値を持つので、処理が継続する前に `smallNumber` により扱いやすい値がセットされます。


```js
let smallNumber = -Number.MAX\_VALUE \* 2;

if (smallNumber === Number.NEGATIVE\_INFINITY) {
  smallNumber = returnFinite();
}
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.negative\_infinity |

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

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

関連情報
----

* `Number.POSITIVE_INFINITY`
* `Number.isFinite()`
* `Infinity`
* `isFinite()`
Number.MAX\_VALUE
=================

**`Number.MAX_VALUE`** 静的データプロパティは、 JavaScript において表すことが可能な最大の数値を表します。

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

値
-

21024 - 1、またはおよそ `1.7976931348623157E+308` です。

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

解説
--

`MAX_VALUE` よりも大きな数値は `Infinity` で表され、正確な値が失われます。

`MAX_VALUE` は `Number` の静的プロパティですので、 数値のプロパティとしてではなく、常に `Number.MAX_VALUE` として使用してください。

例
-

### MAX\_VALUE の使用

以下のコードは、2 つの数値を掛け算しています。その結果が `MAX_VALUE` より小さいか等しい場合は、`func1` 関数が呼び出されます。それ以外の場合は、`func2` 関数が呼び出されます。


```js
if (num1 \* num2 <= Number.MAX\_VALUE) {
  func1();
} else {
  func2();
}
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.max\_value |

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

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

関連情報
----

* `Number.MIN_VALUE`
* 所属先の `Number` オブジェクト
Number.isSafeInteger()
======================

**`Number.isSafeInteger()`** は静的メソッドで、指定された値が*安全な整数*であるかどうかを判定します。

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

構文
--


```js
Number.isSafeInteger(testValue)
```

### 引数

`testValue`

安全な整数かどうかをテストする値です。

### 返値

論理値で、与えられた数値が安全な整数である数値であれば `true` を返します。そうでなければ `false` です。

解説
--

安全な整数とは、 -(253 - 1) から 253 - 1 までのすべての整数であり、両端を含みます (±9,007,199,254,740,991)。安全な整数は次のようなものです。

* 正確に IEEE-754 倍精度数として表現することができる
* その IEEE-754 表現は、他の整数を IEEE-754 の表現に適合するように、丸めた結果にはならない

例えば、253 - 1 は安全な整数です。正確に表現することができ、他の整数は、どの IEEE-754 丸めモードの下で丸めたものにもなっていません。対照的に、253 は安全な整数では*ありません*。これは IEEE-754 で正確に表現できますが、整数値 253 + 1 は直接 IEEE-754 では表現できず、四捨五入や切り捨ての丸めによって 253 になるからです。

完全な精度で ~9 千兆より大きい値や小さい値を扱うには、任意精度演算ライブラリーを使用する必要があります。数値の浮動小数点表現の詳細については、 What Every Programmer Needs to Know about Floating Point Arithmetic を参照してください。s

巨大な整数値については、 `BigInt` 型を使用することを検討してください。

例
-

### isSafeInteger() の使用


```js
Number.isSafeInteger(3); // true
Number.isSafeInteger(2 \*\* 53); // false
Number.isSafeInteger(2 \*\* 53 - 1); // true
Number.isSafeInteger(NaN); // false
Number.isSafeInteger(Infinity); // false
Number.isSafeInteger("3"); // false
Number.isSafeInteger(3.1); // false
Number.isSafeInteger(3.0); // true
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.issafeinteger |

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

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

関連情報
----

* `Number.isSafeInteger` のポリフィル (`core-js`)
* 所属先の `Number` オブジェクト
* `Number.MIN_SAFE_INTEGER`
* `Number.MAX_SAFE_INTEGER`
* `BigInt`
Number.MIN\_SAFE\_INTEGER
=========================

**`Number.MIN_SAFE_INTEGER`** 静的データプロパティは、JavaScript における安全な整数の最小値 (-(253 - 1)) を表します。

これよりも小さな整数値を表す場合は、 `BigInt` を使用することを検討してください。

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

値
-

`-9007199254740991`（-9,007,199,254,740,991、またはおよそ -9 千兆）です。

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

解説
--

倍精度浮動小数点型数値は仮数部を表わすのに 52 ビットしかないため、安全に表現できる整数は -(253 – 1) と 253 – 1 との間です。この文脈で示している「安全」とは、整数を正確に表現し、正しく比較する能力を指します。たとえば、 `Number.MIN_SAFE_INTEGER - 1 === Number.MIN_SAFE_INTEGER - 2` は、数学的には不正確ですが true と評価されます。詳細については `Number.isSafeInteger()` を見てください。

`MIN_SAFE_INTEGER` は `Number` の静的プロパティですので、 数値のプロパティとしてではなく、常に `Number.MIN_SAFE_INTEGER` として使用してください。

例
-

### MIN\_SAFE\_INTEGER の使用


```js
Number.MIN\_SAFE\_INTEGER; // -9007199254740991
-(2 \*\* 53 - 1); // -9007199254740991
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.min\_safe\_integer |

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

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

関連情報
----

* `Number.MIN_SAFE_INTEGER` のポリフィル (`core-js`)
* `Number.MAX_SAFE_INTEGER`
* `Number.isSafeInteger()`
* `BigInt`
Number.isNaN()
==============

**`Number.isNaN()`** は静的メソッドで、渡された値が数値型の `NaN` であるかどうかを判定します。入力が数値型でなかった場合は `false` を返します。元となるグローバルの `isNaN()` よりも堅牢な版です。

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

構文
--


```js
Number.isNaN(value)
```

### 引数

`value`

`NaN` かどうか検査される値です。

### 返値

論理値で、与えられた値が数値で、かつ値が `NaN` である場合は `true` を返します。そうでなければ `false` です。

解説
--

`Number.isNaN()` 関数は、`NaN` と等しいことをチェックする便利な方法を提供します。なお、`NaN` と等しいことは `==` 演算子でも `===` 演算子でも検査できません。JavaScript の他のすべての値との比較とは異なり、一方のオペランドが `NaN` であれば、もう一方のオペランドが `NaN` であっても `false` と評価します。

JavaScript の有効なすべての値の中で、`x !== x` は `NaN` だけが true になりますので、`Number.isNaN(x)` は `x !== x` の検査を置き換えることができますが、後者の方が可読性が低くなります。

グローバルの `isNaN()` 関数とは異なり、 `Number.isNaN()` は強制的に引数が数値に変換される問題の影響をうけません。これにより、通常 `NaN` に変換されるが実際には `NaN` ではない値が、安全に渡されます。つまりこの関数は、数値型であり、かつ `NaN` である値が渡されたときのみ、 `true` を返すということです。

例
-

### isNaN() の使用


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

### Number.isNaN() とグローバルの isNaN() の相違点

`Number.isNaN()` は引数を数値へ変換することを試みないので、数値でないものはすべて `false` を返します。以下のものはすべて `false` になります。


```js
Number.isNaN("NaN");
Number.isNaN(undefined);
Number.isNaN({});
Number.isNaN("blabla");
Number.isNaN(true);
Number.isNaN(null);
Number.isNaN("37");
Number.isNaN("37.37");
Number.isNaN("");
Number.isNaN(" ");
```


グローバルの `isNaN()` は、引数を数値に変換します。


```js
isNaN("NaN"); // true
isNaN(undefined); // true
isNaN({}); // true
isNaN("blabla"); // true
isNaN(true); // false、これは 1 に変換される
isNaN(null); // false、これは 0 に変換される
isNaN("37"); // false、これは 37 に変換される
isNaN("37.37"); // false、これは 37.37 に変換される
isNaN(""); // false、これは 0 に変換される
isNaN(" "); // false、これは 0 に変換される
```

仕様書
---

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

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

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

関連情報
----

* `Number.isNaN` のポリフィル (`core-js`)
* `Number`
* `isNaN()`
Number.NaN
==========

**`Number.NaN`** 静的データプロパティは非数 (Not-A-Number) を表す値であり、`NaN` と同じです。`NaN` の動作についての詳しい情報は、グローバルプロパティの説明を参照してください。

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

値
-

数値 `NaN` です。

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

解説
--

`NaN` は `Number` の静的プロパティですので、数値のプロパティとしてではなく、常に `Number.NaN` として使用してください。

例
-

### 値が数値であるかどうかのチェック


```js
function sanitize(x) {
  if (isNaN(x)) {
    return Number.NaN;
  }
  return x;
}
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.nan |

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

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

関連情報
----

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

**`Number.isInteger()`** は静的メソッドで、渡された値が整数かどうかを判定します。

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

構文
--


```js
Number.isInteger(value)
```

### 引数

`value`

整数かどうかを判定される値です。

### 返値

論理値で、渡された値が整数であれば `true` です。それ以外の場合は `false` です。

解説
--

指定された値が整数の場合は `true` を返し、そうでない場合は `false` を返します。`NaN` もしくは `Infinity` の場合も `false` を返します。このメソッドは整数として表すことができる浮動小数点数も `true` を返します。値が数値でない場合は常に `false` を返します。

数値リテラルの中には、ECMAScript の浮動小数点数エンコーディング (IEEE-754) の精度制限により、整数でないように見えても実は整数を表しているものがあることに注意してください。例えば、`5.0000000000000001` は `5` と `1e-16` だけ異なりますが、これは小さすぎて表しきれません。（参考までに、`Number.EPSILON` は、1 と 1 より大きい次の表現可能な浮動小数点数の間の距離を格納しており、それはおよそ `2.22e-16` です）。したがって、`5.0000000000000001` は `5` と同じエンコーディングで表されますので、`Number.isInteger(5.000000000001)` は `true` を返すことになります。

同様の意味で、`Number.MAX_SAFE_INTEGER` の大きさ前後の数値は精度を失い、整数でなくても `Number.isInteger` が `true`を返すようになる。（実際の閾値は、10 進数を表すのに何ビット必要かによって変わります。例えば、 `Number.isInteger(450000000000.1)` は `true` ですが、 `Number.isInteger(450000000000.5)` は `false` です。）

例
-

### isInteger の使用


```js
Number.isInteger(0); // true
Number.isInteger(1); // true
Number.isInteger(-100000); // true
Number.isInteger(99999999999999999999999); // true

Number.isInteger(0.1); // false
Number.isInteger(Math.PI); // false

Number.isInteger(NaN); // false
Number.isInteger(Infinity); // false
Number.isInteger(-Infinity); // false
Number.isInteger("10"); // false
Number.isInteger(true); // false
Number.isInteger(false); // false
Number.isInteger([1]); // false

Number.isInteger(5.0); // true
Number.isInteger(5.000000000000001); // false
Number.isInteger(5.0000000000000001); // true（精度が落ちるため）
Number.isInteger(4500000000000000.1); // true（精度が落ちるため）
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.isinteger |

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

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

関連情報
----

* `Number.isInteger` のポリフィル (`core-js`)
* このメソッドが所属している `Number` オブジェクト。
Number.parseFloat()
===================

**`Number.parseFloat()`** は静的メソッドで、引数を解釈して浮動小数点値を返します。引数の数値が解釈できない場合は、 `NaN` を返します。

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

構文
--


```js
Number.parseFloat(string)
```

### 引数

`string`

解釈する値で、文字列に変換されます。先頭のホワイトスペースは無視されます。

### 返値

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

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

例
-

### Number.parseFloat と parseFloat

このメソッドは、グローバルの `parseFloat()` 関数と同じ機能を持っています。


```js
Number.parseFloat === parseFloat; // true
```


この目的は、グローバルのモジュール化にあります。

さらなる詳細と例は `parseFloat()` を参照してください。

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.parsefloat |

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

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

関連情報
----

* `Number.parseFloat` のポリフィル (`core-js`)
* `Number`: このメソッドが所属するオブジェクト
* グローバルの `parseFloat()` メソッド
Number.isFinite()
=================

**`Number.isFinite()`** は静的メソッドで、渡された値が有限数であるかどうかを判断します。すなわち、指定された値が数値型であり、その数値が正の無限大 (`Infinity`)、負の無限大 (`Infinity`)、非数 (`NaN`) のどれでもないことをチェックします。

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

構文
--


```js
Number.isFinite(value)
```

### 引数

`value`

有限数かどうかテストされる値。

### 返値

与えられた値が有限数かどうかを示す論理値です。

例
-

### isFinite() の使用


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

Number.isFinite(0); // true
Number.isFinite(2e64); // true
```

### Number.isFinite() とグローバルの isFinite() との違い

グローバルの `isFinite()` 関数と比較すると、このメソッドは最初に引数を数値に変換しません。すなわち、数値型の値で、それが有限数でもある場合のみ `true` を返し、非数については常に `false` を返すということです。


```js
isFinite("0"); // true; coerced to number 0
Number.isFinite("0"); // false
isFinite(null); // true; coerced to number 0
Number.isFinite(null); // false
```

仕様書
---

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

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

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

関連情報
----

* `Number.isFinite` のポリフィル (`core-js`)
* このメソッドが所属している `Number` オブジェクト
* グローバル関数 `isFinite`
Number.prototype.toPrecision()
==============================

**`toPrecision()`** メソッドは `Number` オブジェクトを指定された精度で表した文字列を返します。

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

構文
--


```js
toPrecision()
toPrecision(precision)
```

### 引数

`precision` 省略可

有効数字の数を指定する整数です。

### 返値

`Number` オブジェクトを `precision` で指定された桁で概数化された、固定小数点数、または指数表記で表した文字列です。概数の表現方法については `Number.prototype.toFixed()` メソッドの説明を参照してください。それは `toPrecision()` にも適用されます。

引数 `precision` が省略された場合、 `Number.prototype.toString()` のように振舞います。 `precision` が整数の値ではない場合は、最も近い整数に概数化されます。

例外
--

`RangeError`

`precision` が `1` 以上 100 以下の範囲にない場合に発生します。

例
-

### `toPrecision` の使用


```js
let num = 5.123456;

console.log(num.toPrecision()); // '5.123456'
console.log(num.toPrecision(5)); // '5.1235'
console.log(num.toPrecision(2)); // '5.1'
console.log(num.toPrecision(1)); // '5'

num = 0.000123;

console.log(num.toPrecision()); // '0.000123'
console.log(num.toPrecision(5)); // '0.00012300'
console.log(num.toPrecision(2)); // '0.00012'
console.log(num.toPrecision(1)); // '0.0001'

// なお、場合によっては指数表記が返されることがあります。
console.log((1234.5).toPrecision(2)); // '1.2e+3'
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.prototype.toprecision |

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

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

関連情報
----

* `Number.prototype.toFixed()`
* `Number.prototype.toExponential()`
* `Number.prototype.toString()`
Number.EPSILON
==============

**`Number.EPSILON`** プロパティは、1 と 1 より大きな最小の浮動小数点数の差を表します。

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

値
-

2-52、またはおよそ `2.2204460492503130808472633361816E-16`。

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

解説
--

`Number.EPSILON` は、1 と数値形式で表現できる次に大きな数値との差です。これは、倍精度浮動小数点数形式では仮数部を 52 ビットでしか表現できず、最低ビットは 2-52 で表されるためです。

なお、浮動小数点数の絶対精度は、数が大きくなるにつれ、指数が大きくなる一方で仮数部の精度は変わらないため、低下します。`Number.MIN_VALUE` は表現可能な正の数の最小値であり、`Number.EPSILON` よりもはるかに小さいものです

`EPSILON` は `Number` の静的プロパティなので、数値のプロパティとしてではなく、常に `Number.EPSILON` として使用しています。

例
-

### 同等性のテスト

10 進数や 2 進数など、どのような基数を選んでも、有限のビット数を占める数字エンコーディングシステムは、必然的にすべての数字を正確に表すことができません。なぜなら、有限のメモリーを使用して、数直線上の無限の点を表現しようとすることになるからです。例えば、10 進法では 1/3 を正確に表せませんし、2 進法では `0.1`を正確に表せません。したがって、例えば、`0.1 + 0.2` は `0.3` と正確に等しくはなりません。


```js
console.log(0.1 + 0.2); // 0.30000000000000004
console.log(0.1 + 0.2 === 0.3); // false
```


このため、**浮動小数点数で `===` と比較してはいけない**というアドバイスがたくさんあります。その代わりに、異なる 2 種類の数値が十分に近い場合には、等しいとみなすことができます。`EPSILON`は、要するに `1` という数字がどの程度正確かを指定するものなので、演算結果が `1` 程度の大きさであれば、通常 `Number.EPSILON` 定数がエラーに対する妥当な閾値となります。


```js
function equal(x, y) {
  return Math.abs(x - y) < Number.EPSILON;
}

const x = 0.2;
const y = 0.3;
const z = 0.1;
console.log(equal(x + z, y)); // true
```


しかし、`Number.EPSILON` は、それ以上の大きさの演算処理を行う場合には不適切です。もしデータが 103 程度の大きさであれば、小数点以下の部分は `Number.EPSILON` よりもずっと小さな精度を持つことになります。


```js
function equal(x, y) {
  return Math.abs(x - y) < Number.EPSILON;
}

const x = 1000.1;
const y = 1000.2;
const z = 2000.3;
console.log(x + y); // 2000.3000000000002; error of 10^-13 instead of 10^-16
console.log(equal(x + y, z)); // false
```


この場合、より大きな公差が必要となります。比較する数値の大きさはおよそ `2000` であるので、`2000 * Number.EPSILON` のような乗数で、この例では十分な許容範囲を作ることができます。


```js
function equal(x, y, tolerance = Number.EPSILON) {
  return Math.abs(x - y) < tolerance;
}

const x = 1000.1;
const y = 1000.2;
const z = 2000.3;
console.log(equal(x + y, z, 2000 \* Number.EPSILON)); // true
```


大きさだけでなく、入力の*精度*も考慮することが重要です。例えば、数値がフォーム入力から収集され、入力値が `0.1` のステップでしか調整できない場合（すなわち `<input type="number" step="0.1">`）、データは `0.1` の精度しかないので通常は `0.01` など、はるかに大きな許容差を認めることを意味します。

**メモ:** 有益な教訓：等値検査の閾値として、単純に `Number.EPSILON` を使用しないでくださ い。比較する数値の大きさや精度に適した閾値を使用してください。

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.epsilon |

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

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

関連情報
----

* `Number.EPSILON` のポリフィル (`core-js`)
* 所属先の `Number` オブジェクト
Symbol.match
============

**`Symbol.match`** は、文字列に対して正規表現のマッチングを指定します。この関数は `String.prototype.match()` メソッドによって呼び出されます。

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

説明
--

この関数は、オブジェクトが正規表現の動作をするかどうかを識別するためにも使用されます。たとえば、`String.prototype.startsWith()`, `String.prototype.endsWith()`, `String.prototype.includes()` メソッドは、最初の引数が正規表現であるかどうかを確認し、正規表現である場合は `TypeError` を投げます。ここで、`一致`記号が `false`（または偽値）に設定されている場合、そのオブジェクトが正規表現オブジェクトとして使用されることを意図していないことを示します。

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

例
-

### `isRegExp` チェックを無効にする

以下のコードは `TypeError` を投げます。


```js
"/bar/".startsWith(/bar/);

// Throws TypeError, as /bar/ is a regular expression
// and Symbol.match is not modified.
```


ただし、`Symbol.match` を `false` に設定すると、（`match` プロパティを使用する）`isRegExp` チェックは、オブジェクトが正規表現オブジェクトではないことを示します。結果として、`startsWith` と `endsWith` メソッドは、TypeError を投げません。


```js
var re = /foo/;
re[Symbol.match] = false;
"/foo/".startsWith(re); // true
"/baz/".endsWith(re); // false
```

仕様
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.match |

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

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

関連情報
----

* `Symbol.replace`
* `Symbol.search`
* `Symbol.split`
* `RegExp.prototype[@@match]()`