recursal/MDN huggingface dataset:
Atomics.compareExchange()
=========================

静的な **`Atomics.compareExchange()`** メソッドは、指定された値を配列内の指定した位置に格納し、その値を返します。これは、その位置での古い値が、期待された値と同じであったかどうかを返すものです。これは不可分操作で、変更された値が書き戻されるまで、他の書き込みが行われないことが保証されます。

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

構文
--


```js
Atomics.compareExchange(typedArray, index, expectedValue, replacementValue);
```

### 引数

`typedArray`

共有整数の型付き配列です。 `Int8Array`, `Uint8Array`, `Int16Array`, `Uint16Array`, `Int32Array`, `Uint32Array` の何れかです。

`index`

`typedArray` で `value` と交換する位置です。

`expectedValue`

等価性をチェックする値です。

`replacementValue`

交換する数値です。

### 返値

指定された位置 (`typedArray[index]`) にあった古い値です。

### 例外

* `typedArray` が許可された整数型の何れでもない場合、`TypeError` が発生します。
* `index` が `typedArray` の範囲を超えている場合、 `RangeError` が発生します。
例
-

### compareExchange() の使用


```js
const sab = new SharedArrayBuffer(1024);
const ta = new Uint8Array(sab);
ta[0] = 7;

Atomics.compareExchange(ta, 0, 7, 12); // returns 7, the old value
Atomics.load(ta, 0); // 12
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-atomics.compareexchange |

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

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

関連情報
----

* `Atomics`
* `Atomics.exchange()`
Atomics.store()
===============

静的な **`Atomics.store()`** メソッドは、指定された値を配列内の指定した位置に格納し、その値を返します。

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

構文
--


```js
Atomics.store(typedArray, index, value);
```

### 引数

`typedArray`

整数の型付き配列です。 `Int8Array`, `Uint8Array`, `Int16Array`, `Uint16Array`, `Int32Array`, `Uint32Array` の何れかです。

`index`

`typedArray` で `value` を格納する位置です。

`value`

格納する値です。

### 返値

格納された値です。

### 例外

* `typedArray` が許可された整数型の何れでもない場合、`TypeError` が発生します。
* `index` が `typedArray` の範囲を超えている場合、 `RangeError` が発生します。
例
-

### store() の使用


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

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

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-atomics.store |

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

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

関連情報
----

* `Atomics`
* `Atomics.load()`
Atomics.xor()
=============

**`Atomics.xor()`** は静的メソッドで、配列内の指定した位置にある指定された値とのビット単位の XOR を計算し、その位置にあった古い値を返します。これは不可分操作であり、変更された値が書き戻されるまで他の書き込みが行われないことが保証されます。

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

構文
--


```js
Atomics.xor(typedArray, index, value);
```

### 引数

`typedArray`

整数の型付き配列です。 `Int8Array`、`Uint8Array`、`Int16Array`、`Uint16Array`、`Int32Array`、`Uint32Array`、`BigInt64Array`、`BigUint64Array` のいずれかです。

`index`

`typedArray` の中でビット単位の XOR を計算する位置です。

`value`

ビット単位の XOR を計算する値です。

### 返値

指定された位置にあった古い値 (`typedArray[index]`) です。

### 例外

* `TypeError`: `typedArray` が許可されている整数の型ではなかった場合に発生します。
* `RangeError`: `index` が `typedArray` の範囲を超えていた場合に発生します。
解説
--

 ビット単位の XOR 演算は、 `a` と `b` が異なる場合に 1 になります。
 XOR 演算の真理値表は次の通りです。


| `a` | `b` | `a ^ b` |
| --- | --- | --- |
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |

例えば、ビット単位の XOR では `5 ^ 1` の結果が `0100`、すなわち 10 進数で 4 になります。
```

5  0101
1  0001
   ----
4  0100
```

例
-

### xor の使用


```js
const sab = new SharedArrayBuffer(1024);
const ta = new Uint8Array(sab);
ta[0] = 5;

Atomics.xor(ta, 0, 1); // 古い値である 5 を返す
Atomics.load(ta, 0); // 4
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-atomics.xor |

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

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

関連情報
----

* `Atomics`
* `Atomics.and()`
* `Atomics.or()`
Atomics.isLockFree()
====================

 静的な
 **`Atomics.isLockFree()`**
 メソッドは、 `Atomics` のメソッドが、要素のバイト数が指定された大きさである型付き配列に適用された場合、ロックまたは不可分のハードウェア操作を使用するかどうかを見極めるために使用されます。指定された大きさが整数型の TypedArray 型の BYTES\_PER\_ELEMENT プロパティのいずれでもない場合は、 `false` を返します。

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

構文
--


```js
Atomics.isLockFree(size);
```

### 引数

`size`

チェックするバイト単位の大きさです。

### 返値

`true` または `false` で、操作がロック不要であるかどうかを示します。

例
-

### isLockFree の使用


```js
Atomics.isLockFree(1); // true
Atomics.isLockFree(2); // true
Atomics.isLockFree(3); // false
Atomics.isLockFree(4); // true
Atomics.isLockFree(5); // false
Atomics.isLockFree(6); // false
Atomics.isLockFree(7); // false
Atomics.isLockFree(8); // true
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-atomics.islockfree |

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

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

関連情報
----

* `Atomics`
Atomics.wait()
==============

**`Atomics.wait()`** は静的なメソッドで、 `Int32Array` 中の指定された位置に指定された値が保存されているかどうかを検証し、検証できるまでスリープ、もしくはタイムアウトします。返値は "`ok`", "`not-equal`", "`timed-out`" のいずれかです。

**メモ:** この操作は共有された `Int32Array` に対してのみ可能で、またメインスレッドでは実行できません。

構文
--


```js
Atomics.wait(typedArray, index, value);
Atomics.wait(typedArray, index, value, timeout);
```

### 引数

`typedArray`

共有された `Int32Array`。

`index`

待つ対象となる `typedArray` の中の位置。

`value`

期待される値。

`timeout` 省略可

ミリ秒で表した待ち時間。時間が指定されなかった場合は `Infinity`。

### 返値

文字列で、 "ok", "not-equal", or "timed-out" のいずれか。

### 例外

* typedArray が許可された整数型の何れでもない場合、`TypeError` が発生します。
* index が typedArray の範囲を超えている場合、 `RangeError` が発生します。
例
-

### wait() の使用

次のような共有された `Int32Array` があったとします。


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


読み手のスレッドはスリープし、 0 番目の値が 0 であることを期待して待ちます。これが成立している間、処理は進みません。しかし、書き手のスレッドが新しい値を格納した場合、書き手のスレッドによって通知され、新しい値 (123) が返ります。


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


書き手のスレッドは新しい値を格納し、待っているスレッドに書き込みが完了したことを知らせます。


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

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-atomics.wait |

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

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

関連情報
----

* `Atomics`
* `Atomics.notify()`
Atomics.sub()
=============

静的な **`Atomics.sub()`** メソッドは、配列内の指定した位置の値から減算して、その場所にあった古い値を返します。この不可分操作は、修正された値が書き戻されるまで、ほかの書き込みが発生しないことを保証します。

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

構文
--


```js
Atomics.sub(typedArray, index, value);
```

### 引数

`typedArray`

整数の型付き配列です。 `Int8Array`, `Uint8Array`, `Int16Array`, `Uint16Array`, `Int32Array`, `Uint32Array`, `BigInt64Array`, `BigUint64Array` のいずれかです。

`index`

`typedArray` で `value` を減算する位置です。

`value`

減算する数値です。

### 返値

指定された位置 (`typedArray[index]`) にあった古い値です。

### 例外

* typedArray が許可された整数型の何れでもない場合、`TypeError` が発生します。
* index が typedArray の範囲を超えている場合、 `RangeError` が発生します。
例
-

### sub の使用


```js
const sab = new SharedArrayBuffer(1024);
const ta = new Uint8Array(sab);
ta[0] = 48;

Atomics.sub(ta, 0, 12); // 古い値である 48 を返す
Atomics.load(ta, 0); // 36
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-atomics.sub |

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

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

関連情報
----

* `Atomics`
* `Atomics.add()`
Atomics.and()
=============

静的な **`Atomics.and()`** メソッドは、配列内の指定した位置の値に指定した値でビット単位の AND を計算し、その位置の古い値を返します。これは不可分操作で、修正された値が書き戻されるまで、他の書き込みが起こらないことを保証します。

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

構文
--


```js
Atomics.and(typedArray, index, value);
```

### 引数

`typedArray`

共有整数の型付き配列です。 `Int8Array`, `Uint8Array`, `Int16Array`, `Uint16Array`, `Int32Array`, `Uint32Array` の何れかです。

`index`

`typedArray` でビット単位の AND を計算する位置です。

`value`

ビット単位の AND を取る数値です。

### 返値

指定された位置 (`typedArray[index]`) にあった古い値です。

### 例外

* `typedArray` が許可された整数型の何れでもない場合、`TypeError` が発生します。
* `index` が `typedArray` の範囲を超えている場合、 `RangeError` が発生します。
解説
--

ビット単位の AND 操作は、 `a` と `b` の両方が 1 であった場合のみ 1 を生成します。 AND 操作の真理値表を示します。

| `a` | `b` | `a & b` |
| --- | --- | --- |
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |

例えば、ビット単位の AND を `5 & 1` で行うと、結果は `0001` すなわち 10 進数で 1 となります。
```

5  0101
1  0001
   ----
1  0001
```

例
-

### and() の使用


```js
const sab = new SharedArrayBuffer(1024);
const ta = new Uint8Array(sab);
ta[0] = 5;

Atomics.and(ta, 0, 1); // 古い値である 5 を返す
Atomics.load(ta, 0); // 1
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-atomics.and |

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

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

関連情報
----

* `Atomics`
* `Atomics.or()`
* `Atomics.xor()`
Atomics.add()
=============

静的な **`Atomics.add()`** メソッドは、配列内の指定した位置の値に加算して、その位置の古い値を返します。これは不可分操作で、修正された値が書き戻されるまで、他の書き込みが起こらないことを保証します。

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

構文
--


```js
Atomics.add(typedArray, index, value);
```

### 引数

`typedArray`

共有整数の型付き配列です。 `Int8Array`, `Uint8Array`, `Int16Array`, `Uint16Array`, `Int32Array`, `Uint32Array` の何れかです。

`index`

`typedArray` で `value` を加算する位置です。

`value`

加算する数値です。

### 返値

指定された位置 (`typedArray[index]`) にあった古い値です。

### 例外

* `typedArray` が許可された整数型の何れでもない場合、`TypeError` が発生します。
* `index` が `typedArray` の範囲を超えている場合、 `RangeError` が発生します。
例
-

### add() の使用


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

Atomics.add(ta, 0, 12); // 古い値である 0 を返す。
Atomics.load(ta, 0); // 12
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-atomics.add |

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

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

関連情報
----

* `Atomics`
* `Atomics.sub()`
Atomics.or()
============

静的な **`Atomics.or()`** メソッドは、配列内の指定した位置の値に指定した値でビット単位の OR を計算し、その位置にあった古い値を返します。これは不可分操作で、修正された値が書き戻されるまで、他の書き込みが起こらないことを保証します。

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

構文
--


```js
Atomics.or(typedArray, index, value);
```

### 引数

`typedArray`

整数の型付き配列です。 `Int8Array`, `Uint8Array`, `Int16Array`, `Uint16Array`, `Int32Array`, `Uint32Array`, `BigInt64Array`, `BigUint64Array` の何れかです。

`index`

`typedArray` でビット単位の OR を計算する位置です。

`value`

ビット単位の OR を取る数値です。

### 返値

指定された位置 (`typedArray[index]`) にあった古い値です。

### 例外

* `typedArray` が許可された整数型の何れでもない場合、`TypeError` が発生します。
* `index` が `typedArray` の範囲を超えている場合、 `RangeError` が発生します。
解説
--

ビット単位の OR 操作は、 a と b のどちらかが 1 であった場合に 1 を生成します。 OR 操作の真理値表を示します。

| `a` | `b` | `a | b` |
| --- | --- | --- |
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |

例えば、ビット単位の OR を 5 | 1 で行うと、結果は 0101 すなわち 10 進数で 5 となります。
```

5  0101
1  0001
   ----
5  0101
```

例
-

### or の使用


```js
const sab = new SharedArrayBuffer(1024);
const ta = new Uint8Array(sab);
ta[0] = 2;

Atomics.or(ta, 0, 1); // returns 2, the old value
Atomics.load(ta, 0); // 3
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-atomics.or |

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

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

関連情報
----

* `Atomics`
* `Atomics.and()`
* `Atomics.xor()`
Atomics.notify()
================

静的メソッドである **`Atomics.notify()`** は、待ち行列で休眠状態にあるエージェントに通知します。

**メモ:** この操作は共有された `Int32Array` に対してのみ動作します。
 共有されていない `ArrayBuffer` オブジェクトでは `0` を返します。


構文
--


```js
Atomics.notify(typedArray, index, count);
```

### 引数

`typedArray`

共有された `Int32Array`。

`index`

起動する対象となる `typedArray` 中の位置。

`count` 省略可

通知する休眠状態のエージェントの数。既定値は `+Infinity` です。

### 返値

* 起動したエージェントの数を返します。
* 共有されていない `ArrayBuffer` オブジェクトが使用された場合は、 `0`
 を返します。
### 例外

* `typedArray` が許可された整数型の何れでもない場合、`TypeError` が発生します。
* `index` が `typedArray` の範囲を超えている場合、 `RangeError` が発生します。
例
-

### `notify` の使用

共有された `Int32Array` を用意します。


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


読み手のスレッドは、0 番目の値が 0 であることを期待して休眠状態になります。それが満たされている間は処理が進みません。しかし、書き手のスレッドが新しい値を格納した場合、読み手のスレッドは書き手のスレッドによって起動され、新しい値 (123) を取得します。


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


書き手のスレッドは新しい値を格納し、待機中のスレッドに通知を行います。


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

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-atomics.notify |

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

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

関連情報
----

* `Atomics`
* `Atomics.wait()`
Atomics.load()
==============

静的な **`Atomics.load()`** メソッドは、配列内の指定された位置の値を返します。

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

構文
--


```js
Atomics.load(typedArray, index);
```

### 引数

`typedArray`

整数の型付き配列です。 `Int8Array`, `Uint8Array`, `Int16Array`, `Uint16Array`, `Int32Array`, `Uint32Array` の何れかです。

`index`

`typedArray` の中で値を読み込む位置。

### 返値

指定された位置 (`typedArray[index]`) にある値です。

### 例外

* `typedArray` が許可された整数型の何れでもない場合、`TypeError` が発生します。
* `index` が `typedArray` の範囲を超えている場合、 `RangeError` が発生します。
例
-

### `load` の使用


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

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

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-atomics.load |

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

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

関連情報
----

* `Atomics`
* `Atomics.store()`
WeakRef() コンストラクター
==================

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

構文
--


```js
new WeakRef(target)
```


**メモ:** `WeakRef()` は `new` との組み合わせでのみ構築されます。 `new` 無しで呼び出そうとすると `TypeError` が発生します。

### 引数

`target`

WeakRef の参照先となるターゲット値（リファレントとも呼ばれます）。オブジェクトまたは未登録のシンボルでなければなりません。

### 返値

指定されたターゲット地を参照する `WeakRef` オブジェクトです。

### 例外

`TypeError`

`target` がオブジェクトまたは未登録のシンボルではない場合に発生します。

例
-

### 新しい WeakRef オブジェクトの生成

完全な例は中心となる `WeakRef` ページを参照してください。


```js
class Counter {
  constructor(element) {
    // DOM 要素への弱い参照を覚える
    this.ref = new WeakRef(element);
    this.start();
  }
}
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-weak-ref-constructor |

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

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

関連情報
----

* `WeakRef`
WeakRef.prototype.deref()
=========================

`deref` メソッドは `WeakRef` インスタンスのターゲットオブジェクトを返します。そのオブジェクトが既にガベージコレクションされている場合は `undefined` を返します。

構文
--


```js
deref()
```

### 引数

なし。

### 返値

WeakRef の参照先となるターゲット値で、オブジェクトまたは未登録のシンボルでなければなりません。そのオブジェクトが既にガベージコレクションされている場合は `undefined` です。

解説
--

重要な注意事項については `WeakRef` ページの WeakRef の注意事項の節を参照してください。

例
-

### deref の使用

完全な例については `WeakRef` ページ内の例の節を参照してください。


```js
const tick = () => {
  // 弱参照から要素を取得する (まだ存在していれば)
  const element = this.ref.deref();
  if (element) {
    element.textContent = ++this.count;
  } else {
    // 要素が既に存在しない場合
    console.log("この要素は消滅しました");
    this.stop();
    this.ref = null;
  }
};
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-weak-ref.prototype.deref |

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

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

関連情報
----

* `WeakRef`
Number.parseInt()
=================

**`Number.parseInt()`** は静的メソッドで、文字列の引数を解釈し、指定された基数の整数値を返します。

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

構文
--


```js
Number.parseInt(string)
Number.parseInt(string, radix)
```

### 引数

`string`

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

`radix` 省略可

`2` から `36` までの整数で、 `string` の*基数*（数学的記数法の底）を表します。

`radix` が未定義または `0` であった場合、通常は `10` と見なされますが、数値が `0x` または `0X` のコードの組み合わせであった場合は `16` と見なされます。

### 返値

指定された `string` を解析した整数値です。

`radix` が `2` よりも小さいか `36` よりも大きい、または最初のホワイトスペース以外の文字が数値に変換できない場合は `NaN` が返されます。

例
-

### Number.parseInt と parseInt

このメソッドはグローバル関数の `parseInt()` と同じです。


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


この目的は、グローバル値のモジュール化のためです。詳細や例は `parseInt()` を参照してください。

仕様書
---

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

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

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

関連情報
----

* `Number.parseInt` のポリフィル (`core-js`)
* 所属先の `Number` オブジェクト
* グローバルメソッドの `parseInt()`
Number.POSITIVE\_INFINITY
=========================

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

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

値
-

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

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

解説
--

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

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

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

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

例
-

### POSITIVE\_INFINITY の使用

以下の例では、変数 `bigNumber` に最大値よりも大きな値が代入されています。`if` 文が実行されるとき、`bigNumber` は `Infinity` の値を持つので、処理が継続する前に `bigNumber` により扱いやすい値がセットされます。


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

if (bigNumber === Number.POSITIVE\_INFINITY) {
  bigNumber = returnFinite();
}
```

仕様書
---

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

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

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

関連情報
----

* `Number.NEGATIVE_INFINITY`
* `Number.isFinite()`
* `Infinity`
* `isFinite()`
Number() コンストラクター
=================

**`Number()`** コンストラクターは、 `Number` オブジェクトを生成します。関数として呼び出された場合は、数値型のプリミティブ値を返します。

構文
--


```js
new Number(value)
Number(value)
```


**メモ:** `Number()` は `new` を付けてもつけなくても呼び出せますが、効果は異なります。返値を参照してください。

### 引数

`value`

作成するオブジェクトの数値です。

### 返値

`Number` がコンストラクターとして（`new` 付きで）呼び出された場合は、`Number` オブジェクトを作成します。これはプリミティブでは**ありません**。

`Number` が関数として呼び出された場合、引数を数値プリミティブに変換します。長整数 (BigInt) は数値へ変換されます。値が変換できない場合は、`NaN` を返します。

**警告:** コンストラクターとして `Number` を使用することはほとんどないはずです。

例
-

### Number オブジェクトの生成


```js
const a = new Number("123"); // a === 123 は false
const b = Number("123"); // b === 123 は true
a instanceof Number; // は true
b instanceof Number; // は false
typeof a; // "object"
typeof b; // "number"
```

### Number() を使用して長整数を数値へ変換

`Number()` は、とても明示的なので、例外を発生させずに長整数 (BigInt) を数値に変換することができる唯一のケースです。


```js
+1n; // TypeError: Cannot convert a BigInt value to a number
0 + 1n; // TypeError: Cannot mix BigInt and other types, use explicit conversions
```



```js
Number(1n); // 1
```


なお、長整数が安全に表現するのに長すぎる場合、精度が下がることがあります。


```js
BigInt(Number(2n \*\* 54n + 1n)) === 2n \*\* 54n + 1n; // false
```

仕様書
---

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

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

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

関連情報
----

* 現在の `Number` の動作（2 進数と 8 進数のリテラルの対応あり）のポリフィル (`core-js`)
* `NaN`
* `Math` グローバルオブジェクト
* 可変精度の整数: `BigInt`
Number.MAX\_SAFE\_INTEGER
=========================

**`Number.MAX_SAFE_INTEGER`** 定数は、JavaScript における安全な整数の最大値 (253 – 1) を表します。

もっと大きな整数には、 `BigInt` を使用することを検討してください。

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

値
-

`9007199254740991` （9,007,199,254,740,991、または ~9 千兆）。

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

解説
--

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

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

例
-

### MAX\_SAFE\_INTEGER の返値


```js
Number.MAX\_SAFE\_INTEGER; // 9007199254740991
```

### MAX\_SAFE\_INTEGER と EPSILON の関係

`Number.EPSILON` は 2-52 であり、 `MAX_SAFE_INTEGER` は 253 - 1 です。どちらも仮数部の幅である 53 ビット（最上位ビットは常に 1）から来ています。これらを乗算すると、2 にとても近い（しかし等しくはない）値が得られます。


```js
Number.MAX\_SAFE\_INTEGER \* Number.EPSILON; // 1.9999999999999998
```

仕様書
---

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

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

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

関連情報
----

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

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

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

値
-

2-1074、または `5E-324` です。

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

解説
--

`Number.MIN_VALUE` プロパティは、浮動小数点の精度で表すことができる最小の正の数です（最も小さな負の数ではありません）。言い換えれば、最も 0 に近い数です。ECMAScript の仕様書では、実装が対応する必要のある精度を定義していません。代わりに仕様書では、「その実装で実際に表すことができる、 0 ではない最も小さな正の数でなければならない」とあります。これは、小さな IEEE-754 浮動小数点数では非正規化されるためですが、実装するためにこの表現に対応する必要はなく、その場合は `Number.MIN_VALUE` が大きくなる可能性があります。

実際、V8（Chrome、Edge、Node.js で使用）、SpiderMonkey（Firefox で使用）、JavaScriptCore（Safari で使用）などの主なエンジンにおける正確な値は、 2-1074 または `5E-324` です。

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

例
-

### MIN\_VALUE の使用

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


```js
if (num1 / num2 >= Number.MIN\_VALUE) {
  func1();
} else {
  func2();
}
```

仕様書
---

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

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

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

関連情報
----

* `Number.MAX_VALUE`
Number.prototype.valueOf()
==========================

**`valueOf()`** メソッドは `Number` オブジェクトがラップしているプリミティブ値を返します。

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

構文
--


```js
valueOf()
```

### 返値

指定した `Number` オブジェクトのプリミティブ値を表した数値です。

解説
--

このメソッドは、通常は JavaScript によって内部的に呼び出されるものであり、ウェブのコード中で明示的に呼び出されることはありません。

例
-

### valueOf の使用


```js
const numObj = new Number(10);
console.log(typeof numObj); // object

const num = numObj.valueOf();
console.log(num); // 10
console.log(typeof num); // number
```

仕様書
---

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

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

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

関連情報
----

* `Object.prototype.valueOf()`