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

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

メモ

概要

  • 任意精度の整数を表すオブジェクト
    • 整数のみを表現 (NaN・Undefined 等はなし)
    • 最大値・最小値：仕様上は制限なし
      Number【数値】の Number.MAX_SAFE_INTEGER【正確な最大整数値】 (9,007,199,254,740,991) よりも大きな整数値を表現可能
    • 0n と -0n の区別なし
    • +(プラス記号)付きの正数は例外 (演算等 参照)
    • Number【数値】との演算は不可、比較は可 (Number型 を BigInt型 に変換後に演算)
    • new での生成やサブクラス化には未対応
    • 数値セパレータ使用可 (例：1_234_567n)
  • BigInt型【任意精度整数型】も同等の処理が可能 (一時的に BigInt【任意精度整数】オブジェクト を作成)

変換

関連

外部リンク

リテラル

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

リテラル例説明
[-]Num～Numn 9007199254740991n
0n 		10進数
Num：0～9
[-]0bBin～Binn
[-]0BBin～Binn 		0b1111n
-0B1111n 		2進数
Bin：0・1
[-]0oOct～Octn
[-]0OOct～Octn 		0o7777n
-0O7777n 		8進数
Oct：0～7
[-]0xHex～Hexn
[-]0XHex～Hexn 		0xffffn
-0XFFFFn 		16進数
Hex：0～9・a～f・A～F
※ 数値セパレータ
　 数値部分をアンダースコア (_) で区切ることが可能
  • 先頭 及び 末尾 は不可
  • 先頭の 0 の直後は不可
  • 連続使用は不可

コンストラクタ・型変換

メソッド説明
new BigIntnew による生成・サブクラス化は不可
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プロトタイプ
(定数)未定義

演算等

x・y は 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 値を -2 bits - 1 ～ 2 bits - 1 - 1 の範囲に丸め)
( bits に 64 (8バイト) を指定すると、C言語の long int の範囲に丸まる )
：丸められたBigInt型整数
bits：ビット数
bigint：丸める整数値
BigInt. asUintN( bits, bigint ) 符号なし整数に丸め (bigint 値を 0 ～ 2 bits - 1 の範囲に丸め)
( bits に 64 (8バイト) を指定すると、C言語の unsigned long int の範囲に丸まる )
：丸められたBigInt型整数
bits：ビット数
bigint：丸める整数値
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

let big = 1_234_567n;
console.log(big);
// 出力：1234567n

big = 0b1111_0000n;
console.log(big);
// 出力：240n

big = 0o777_000n;
console.log(big);
// 出力：261632n

big = 0xff_00n;
console.log(big);
// 出力：65280n