BigInt

Baseline Widely available

This feature is well established and works across many devices and browser versions. Itâs been available across browsers since 2020å¹´9æ.

BigInt æ¯ä¸åå§å»ºçç©ä»¶ï¼æä¾äºè¡¨ç¤ºå¤§æ¼ 2^53 çæ´æ¸çåè½ (2^53 æ¯ JavaScript åççNumberè½å¤ è¡¨ç¤ºçæå¤§å¼)

èªæ³

BigInt(value);

åæ¸

value: æ¬²åµå»ºçæ¸å¼ï¼å¯ä»¥çºæ´æ¸æåä¸²ã

åè¨»ï¼BigInt() ä¸å new ä¸èµ·ä½¿ç¨ã

èªªæ

BigInt æ¯ééå¨ä¸åæ¸å¼å¾å ä¸ n ï¼ä¾å¦ 10n ï¼æå¼å« BigInt() æçæçã

const theBiggestInt = 9007199254740991n;

const alsoHuge = BigInt(9007199254740991);
// âª 9007199254740991n

const hugeString = BigInt("9007199254740991");
// âª 9007199254740991n

const hugeHex = BigInt("0x1fffffffffffff");
// âª 9007199254740991n

const hugeBin = BigInt(
  "0b11111111111111111111111111111111111111111111111111111",
);
// âª 9007199254740991n

è¦åï¼Number å BigInt ä¸è½æ··åè¨ç® â ä»åå¿é è¢«è½æå°åä¸ååæã

é¡å¥è³è¨

ç¶ä½¿ç¨ typeof æ¸¬è©¦æï¼ä¸å BigInt æåå³ "bigint"ï¼

typeof 1n === "bigint"; // true
typeof BigInt("1") === "bigint"; // true

ç¶ä½¿ç¨ Object ä¾åè£¹æï¼BigInt æè¢«çææ¯æ®éç "object" åæï¼

typeof Object(1n) === "object"; // true

Operator

ä¸åçéç®åå¯ä»¥è¢«ç¨å¨ BigInt ä¸ (æç± object åè£¹ç BigInt): +, *, -, **, %.

const previousMaxSafe = BigInt(Number.MAX_SAFE_INTEGER);
// âª 9007199254740991

const maxPlusOne = previousMaxSafe + 1n;
// âª 9007199254740992n

const theFuture = previousMaxSafe + 2n;
// âª 9007199254740993n, this works now!

const multi = previousMaxSafe * 2n;
// âª 18014398509481982n

const subtr = multi â 10n;
// âª 18014398509481972n

const mod = multi % 10n;
// âª 2n

const bigN = 2n ** 54n;
// âª 18014398509481984n

bigN * -1n
// âª â18014398509481984n

const expected = 4n / 2n;
// âª 2n

const rounded = 5n / 2n;
// âª 2n, not 2.5n

æ¯è¼

ä¸å BigInt ä¸¦ä¸å´æ ¼çæ¼ä¸å Numberï¼ä½ä»åæä¸è¬ç¸çã

0n === 0;
// âª false

0n == 0;
// âª true

ä¸å Number å BigInt å¯ä»¥åæ®ééç®ä¸æ¨£æ¯è¼ã

1n < 2;
// âª true

2n > 1;
// âª true

2 > 2;
// âª false

2n > 2;
// âª false

2n >= 2;
// âª true

ä»åå¯ä»¥åéå¨é£åä¸ä¸¦ç§é æçè¢«æåºã

const mixed = [4n, 6, -12n, 10, 4, 0, 0n];
// âª  [4n, 6, -12n, 10, 4, 0, 0n]

mixed.sort();
// âª [-12n, 0, 0n, 10, 4n, 4, 6]

Note that comparisons with Object-wrapped BigInts act as with other objects, only indicating equality when the same object instance is compared:

0n === Object(0n); // false
Object(0n) === Object(0n); // false

const o = Object(0n);
o === o; // true

A BigInt behaves like a Number in cases where it is converted to a Boolean: via the Boolean function; when used with logical operators Logical Operators ||, &&, and !; or within a conditional test like an if statement.

if (0n) {
  console.log("Hello from the if!");
} else {
  console.log("Hello from the else!");
}

// âª "Hello from the else!"

0n || 12n;
// âª 12n

0n && 12n;
// âª 0n

Boolean(0n);
// âª false

Boolean(12n);
// âª true

!12n;
// âª false

!0n;
// âª true

æ¹æ³

BigInt.asIntN(): Clamps a BigInt value to a signed integer value, and returns that value.
BigInt.asUintN(): Clamps a BigInt value to an unsigned integer value, and returns that value.

å±¬æ§

All BigInt instances inherit from BigInt.prototype. The prototype object of the BigInt constructor can be modified to affect all BigInt instances.

æ¹æ³

BigInt.prototype.toLocaleString(): Returns a string with a language-sensitive representation of this BigInt value. Overrides the Object.prototype.toLocaleString() method.
BigInt.prototype.toString(): Returns a string representing this BigInt value in the specified radix (base). Overrides the Object.prototype.toString() method.
BigInt.prototype.valueOf(): Returns this BigInt value. Overrides the Object.prototype.valueOf() method.

function isPrime(p) {
  for (let i = 2n; i * i <= p; i++) {
    if (p % i === 0n) return false;
  }
  return true;
}

// Takes a BigInt as an argument and returns a BigInt
function nthPrime(nth) {
  let maybePrime = 2n;
  let prime = 0n;

  while (nth >= 0n) {
    if (isPrime(maybePrime)) {
      nth -= 1n;
      prime = maybePrime;
    }
    maybePrime += 1n;
  }

  return prime;
}

nthPrime(20n);
// âª 73n