BigInt【任意精度整数】オブジェクト

メモ リテラル コンストラクタ・型変換 プロパティ・定数 演算等 メソッド 外部リンク

メモ


リテラル

数値の末尾にnを記述、プラス記号は不可

リテラル説明
[-]NumNumn 9007199254740991n
0n
10進数
Num:0~9
[-]0bBinBinn
[-]0BBinBinn
0b1111n
-0B1111n
2進数
Bin:0・1
[-]0oOctOctn
[-]0OOctOctn
0o7777n
-0O7777n
8進数
Oct:0~7
[-]0xHexHexn
[-]0XHexHexn
0xffffn
-0XFFFFn
16進数
Hex:0~9・a~f・A~F

コンストラクタ・型変換

メソッド説明
new BigInt()new による生成・サブクラス化は不可
BigInt( value ) BigInt型変換
戻り値:BigInt型整数
value:各種型
BigInt:そのまま
Boolean:true は 1n、false は 0n
Number:整数値は型変換、その他は RangeError 例外
String:整数値は型変換、その他は SyntaxError 例外
その他:TypeError 例外

プロパティ・定数

プロパティ・定数説明
BigInt.prototype[ @@toStringTag ] タグ
bigint[ Symbol.toStringTag ]:"BigInt"
BigInt.prototype.constructorコンストラクタ定義
BigInt.prototypeプロトタイプ
(定数)未定義

演算等

xy は BigInt 型
Number 型との演算は不可 (比較は可能):暗黙の変換は無いので明示的に変換

演算等説明
+x プラス記号付き正数 (例:+0n・+123n・+big)
TypeError 例外:BigInt から Number への変換不可
-x負数
~x1の補数
x ** y べき乗 ( x y )
y が 0n より小さい場合、RangeError 例外
x * y乗算
x / y除算
y が 0n の場合、RangeError 例外
x % y剰余
x ++
++ x
x + y
加算
x --
-- x
x - y
減算
x << y左ビットシフト
x >> y符号あり右ビットシフト
x >>> y符号なし右ビットシフト
x < y
x > y
x <= y
x >= y
大小比較
x == y
x != y
x === y
x !== y
等値・同値 比較
(0n と -0n の区別なし)
x & yビット毎の AND
x ^ yビット毎の XOR
x | yビット毎の OR
String( x )文字列変換 ( BigInt.toString()呼び出し )

メソッド

メソッド説明
BigInt. asIntN( bits, bigint ) 符号付き整数に丸め
戻り値:丸められたBigInt型整数
bigint:丸める整数値
bits:ビット数
bigint 値を -2 bits - 1 ~ 2 bits - 1 - 1 の範囲に丸め
( bits に 64 (8バイト) を指定すると、C言語の long int の範囲に丸まる )
BigInt. asUintN( bits, bigint ) 符号なし整数に丸め
戻り値:丸められたBigInt型整数
bigint:丸める整数値
bits:ビット数
bigint 値を 0 ~ 2 bits - 1 の範囲に丸め
( bits に 64 (8バイト) を指定すると、C言語の unsigned long int の範囲に丸まる )
BigInt.prototype. toLocaleString( [ reserved1 [ , reserved2 ] ])
toLocaleString( [ locales [ , options ] ])
文字列変換 (ロケール)
実装依存:3桁区切り・通貨 等
戻り値:ロケールに対応した文字列
reserved1:リザーブ
reserved2:リザーブ
locales:ロケール
options:オプション
BigInt.prototype. toString( [ radix ] ) 文字列変換 (基数指定可)
戻り値:基数に対応した文字列
radix:基数 (省略:10 / 2 ~ 36)
BigInt.prototype. valueOf( ) BigInt値 取得
戻り値:BigInt値

let num = Number.MAX_SAFE_INTEGER;
let big = BigInt(num);
console.log(num++, big++);
// 出力:9007199254740991 9007199254740991n
console.log(num++, big++);
// 出力:9007199254740992 9007199254740992n
console.log(num++, big++);
// 出力:9007199254740992 9007199254740993n

big = 1000000000000002n * 1000000000000003n;
console.log(big.toLocaleString());
// 出力:1,000,000,000,000,005,000,000,000,000,006

// リテラル
big = 0n;
console.log(big);
// 出力:0n
big = 0b1111n;
console.log(big);
// 出力:15n
big = 0o7777n;
console.log(big);
// 出力:4095n
big = 0xffffn;
console.log(big);
// 出力:65535n

// 型変換
big = BigInt(123n);
console.log(big);
// 出力:123n
const bigTrue = BigInt(true);
const bigFalse = BigInt(false);
console.log(bigTrue, bigFalse);
// 出力:1n 0n
big = BigInt(1234);
console.log(big);
// 出力:1234n
big = BigInt("12345");
console.log(big);
// 出力:12345n
// asIntN()
for (let big = -9n; big <= 8n; big++) {
  console.log(big, BigInt.asIntN(4, big));
}
// 出力:-9n 7n
// 出力:-8n -8n
// 出力:-7n -7n
// 出力:-6n -6n
// 出力:-5n -5n
// 出力:-4n -4n
// 出力:-3n -3n
// 出力:-2n -2n
// 出力:-1n -1n
// 出力:0n 0n
// 出力:1n 1n
// 出力:2n 2n
// 出力:3n 3n
// 出力:4n 4n
// 出力:5n 5n
// 出力:6n 6n
// 出力:7n 7n
// 出力:8n -8n

const longMin = -0x8000_0000_0000_0000n;
const longMax = 0x7FFF_FFFF_FFFF_FFFFn;
let longArray = [(longMin - 1n), longMin, longMax, (longMax + 1n)];
for (let i = 0; i < longArray.length; i++) {
  let big = longArray[i];
  console.log(big.toString(16), BigInt.asIntN(64, big).toString(16));
}
// 出力:-8000000000000001 7fffffffffffffff
// 出力:-8000000000000000 -8000000000000000
// 出力:7fffffffffffffff 7fffffffffffffff
// 出力:8000000000000000 -8000000000000000

// asUintN()
for (let big = 0n; big <= 16n; big++) {
  console.log(big, BigInt.asUintN(4, big));
}
// 出力:0n 0n
// 出力:1n 1n
// 出力:2n 2n
// 出力:3n 3n
// 出力:4n 4n
// 出力:5n 5n
// 出力:6n 6n
// 出力:7n 7n
// 出力:8n 8n
// 出力:9n 9n
// 出力:10n 10n
// 出力:11n 11n
// 出力:12n 12n
// 出力:13n 13n
// 出力:14n 14n
// 出力:15n 15n
// 出力:16n 0n

const ulongMin = 0n;
const ulongMax = 0xFFFF_FFFF_FFFF_FFFFn;
let ulongArray = [(ulongMin - 1n), ulongMin, ulongMax, (ulongMax + 1n)];
for (let i = 0; i < ulongArray.length; i++) {
  let big = ulongArray[i];
  console.log(big.toString(16), BigInt.asUintN(64, big).toString(16));
}
// 出力:-1 ffffffffffffffff
// 出力:0 0
// 出力:ffffffffffffffff ffffffffffffffff
// 出力:10000000000000000 0

// toLocaleString()
let big = 1234567890123456n;
console.log(big.toLocaleString());
// 出力:1,234,567,890,123,456
console.log(big.toLocaleString('ja-JP', { style: 'currency', currency: 'JPY' }));
// 出力:¥1,234,567,890,123,456

// toString()
console.log(big.toString());
// 出力:1234567890123456
let bigHex = BigInt(0x111122223333);
console.log(bigHex.toString());
// 出力:18765284782899
console.log(bigHex.toString(16));
// 出力:111122223333

// valueOf()
console.log(typeof big, big.valueOf());
// 出力:bigint 1234567890123456n
const obj = Object(big);
console.log(typeof obj, obj.valueOf());
// 出力:object 1234567890123456n

ECMAScript (英語)

6.1.6 Numeric Types
ES2020 (11) ES2019 (10)ES2018 (9)ES2017 (8) ES2016 (7)ES2015 (6)ES5.1
6.1.6.2 The BigInt Type
ES2020 (11) ES2019 (10)ES2018 (9)ES2017 (8) ES2016 (7)ES2015 (6)ES5.1
11.8.3 Numeric Literals
ES2020 (11) ES2019 (10)ES2018 (9)ES2017 (8) ES2016 (7)ES2015 (6)ES5.1
20.2 BigInt Objects
ES2020 (11) ES2019 (10)ES2018 (9)ES2017 (8) ES2016 (7)ES2015 (6)ES5.1
20.2.2 Properties of the BigInt Constructor
ES2020 (11) ES2019 (10)ES2018 (9)ES2017 (8) ES2016 (7)ES2015 (6)ES5.1