深入理解 JavaScript BigInt：突破数字精度的限制

在 JavaScript 的日常开发中，我们通常习惯了使用 INLINECODEef4e76ec 类型来处理所有的数值计算。然而，当我们试图处理那些极其巨大的整数时——例如数据库中的唯一 ID、高精度的科学计算或密码学应用中的大质数——你可能会遇到一个令人头疼的问题：精度丢失。这是因为在 JavaScript 中，INLINECODE86e4d640 类型基于 IEEE 754 标准的双精度浮点数，它能够安全表示的整数范围有限（$2^{53} – 1$）。一旦超过这个界限，计算结果就不再可靠。

幸运的是，ES2020 为我们引入了一个全新的原生对象——BigInt。在这篇文章中，我们将深入探讨 BigInt 的方方面面，看看它如何帮助我们突破数字精度的限制，以及在实战中如何正确、高效地使用它。准备好告别精度丢失的烦恼了吗？让我们开始吧。

1. 为什么我们需要 BigInt？

在 JavaScript 中，所有数字在默认情况下都是以 64 位浮点数形式存储的。这意味着，虽然它们可以表示非常大的数值，但无法保证所有整数在该范围内都能精确表示。Number.MAX_SAFE_INTEGER 常量告诉我们，这个安全上限是 $2^{53} – 1$（即 9007199254740991）。

让我们来看看如果不使用 BigInt，会发生什么有趣（且危险）的情况：

// 尝试在不安全范围内进行计算
const maxSafe = Number.MAX_SAFE_INTEGER; // 9007199254740991

console.log(maxSafe + 1); // 9007199254740992 (看起来没问题)
console.log(maxSafe + 2); // 9007199254740992 (等等！结果一样？)
console.log(maxSafe + 3); // 9007199254740994 (跳过了一个数)

// 比较运算也会变得诡异
console.log(maxSafe + 1 === maxSafe + 2); // true！这显然是错误的逻辑

正如你在上面的代码中看到的，当超过安全整数限制时，JavaScript 无法再精确区分相邻的整数。这对于处理金融数据或唯一标识符来说是不可接受的。为了解决这个问题，BigInt 应运而生，它允许我们表示任意大小的整数，不再受 $2^{53}$ 的限制。

2. 创建 BigInt 的两种方式

在 JavaScript 中，我们有两种主要方式来创建一个 BigInt。我们可以根据代码的上下文和可读性需求，选择最合适的一种。

#### 方式一：使用 BigInt() 构造函数

当你需要从非整数字面量（如字符串、变量或计算结果）创建 BigInt 时，INLINECODE6fe2607b 函数是非常实用的。它的工作原理类似于 INLINECODE510820f9，可以将传入的值转换为 BigInt 类型。

值得注意的是： 传递给 BigInt() 的参数必须是整数，否则会抛出错误。此外，为了确保最大精度，通常建议传入字符串形式的数字。

// 从字符串创建 BigInt（推荐方式，避免精度丢失）
let bigNum = BigInt("123456789012345678901234567890");
console.log(bigNum); 
// 输出: 123456789012345678901234567890n

// 从十六进制字符串创建
// 这在处理颜色编码或内存地址时非常有用
let bigHex = BigInt("0x1ffffffeeeeeeeeef");
console.log(bigHex);
// 输出: 36893488074118328047n

// 从二进制字符串创建
// 适合进行位运算相关的场景
let bigBin = BigInt("0b1010101001010101001111111111111111");
console.log(bigBin);
// 输出: 11430854655n

// ⚠️ 注意：直接使用数字作为参数时要小心
// 如果数字字面量超过了 Number 的精度范围，
// 在传给 BigInt 之前就已经丢失了精度
let wrongWay = BigInt(12345678901234567890); // 数字本身可能已经被截断
console.log(wrongWay); // 这里的结果可能不是你预期的 123...890

语法与参数：

• 语法：BigInt(value)
• 参数：value 可以是一个整数、字符串或布尔值。如果是浮点数，则会报错。
• 返回值：一个 BigInt 类型的值。

#### 方式二：使用字面量语法（追加 n）

如果你在代码中直接书写大整数，最简洁的方法是在整数字面量的末尾追加 n。这种方式不仅代码更短，而且阅读起来也更加直观，一眼就能看出这是一个大整数。

// 十进制字面量
let bigNum = 123422222222222222222222222222222222222n;
console.log(bigNum);
// 输出: 123422222222222222222222222222222222222n

// 十六进制字面量 (0x...n)
let bigHex = 0x1ffffffeeeeeeeeefn;
console.log(bigHex);
// 输出: 36893488074118328047n

// 二进制字面量 (0b...n)
let bigBin = 0b1010101001010101001111111111111111n;
console.log(bigBin);
// 输出: 11430854655n

// 八进制字面量 (0o...n)
let bigOct = 0o777777777777n;
console.log(bigOct);
// 输出: 8589934591n

实用见解：当你使用字面量语法时，请确保不要省略那个 INLINECODEb26a09e2。如果你写 INLINECODE6dc4f18f 和 const y = 123n;，它们在内存中是完全不同的类型，这一点我们在下一节会详细讨论。

3. 类型检查与比较：BigInt 是独一无二的

BigInt 是 JavaScript 中的第八种原始类型。虽然它看起来像数字，但在类型系统中，它是独立的。这意味着我们不能简单地将它与普通的 Number 混用。

#### 严格类型检查

首先，让我们看看如何识别一个 BigInt：

// 使用 typeof 操作符
console.log(typeof 100); // "number"
console.log(typeof 100n); // "bigint"

// 严格相等比较 (===)
// 由于类型不同，即使数值看起来一样，它们也不相等
console.log(100 === 100n); // false
console.log(100 == 100n);  // false (宽松相等也不成立，这是 BigInt 的特性)

// 判断类型最稳妥的方式
const isBigInt = (value) => {
  return typeof value === ‘bigint‘;
};

console.log(isBigInt(1)); // false
console.log(isBigInt(1n)); // true

#### 排序与混合比较

虽然不能直接进行算术运算，但 BigInt 支持与 Number 进行比较运算（如 INLINECODE028eaffc, INLINECODE4c1e93d3, INLINECODE8dffcf24, INLINECODEe8ded836）。这是因为数学上的大小比较是有意义的，JavaScript 引擎会在内部自动处理数值的转换比较。

// 比较运算符可以正常工作
console.log(1n  1);    // true
console.log(2n > 2);    // false
console.log(2n >= 2);   // true

// 在数组排序中混合使用
// 我们可以直接对包含 Number 和 BigInt 的数组进行排序
let mixedArray = [4, 2, 5n, 2n];

// sort 方法会将它们视为数值进行比较
mixedArray.sort();

console.log(mixedArray); 
// 输出: [2, 2n, 4, 5n]
// 注意：sort() 默认将元素转换为字符串进行比较，
// 但对于数字和 BigInt，这种默认行为恰好符合数值顺序。
// 为了严谨，工业界建议提供 compareFunction:
mixedArray.sort((a, b) => (a  b ? 1 : 0));

// 加法
let sum = 1n + 2n;
console.log(sum); // 3n

// 减法
let diff = 10n - 5n;
console.log(diff); // 5n

// 乘法
let product = 123456789n * 987654321n;
console.log(product); // 121932631112635269n

// 除法 (注意：结果会被向下取整)
let division = 10n / 3n;
console.log(division); // 3n (而不是 3.33...n)

// 取模
let remainder = 10n % 3n;
console.log(remainder); // 1n

// 指数运算
let power = 2n ** 10n;
console.log(power); // 1024n

// ❌ 错误示范：混合类型运算
try {
  // 这会抛出 TypeError: Cannot mix BigInt and other types
  let badSum = 1n + 1; 
} catch (e) {
  console.error(e.message);
}

// 按位与 (AND)
console.log(5n & 3n); // 1n (0101 & 0011)

// 按位或 (OR)
console.log(5n | 3n); // 7n (0101 | 0011)

// 按位异或 (XOR)
console.log(5n ^ 3n); // 6n (0101 ^ 0011)

// 左移
console.log(1n <> 2n); // 8n

// ❌ 无符号右移不支持
// console.log(5n >>> 1n); // SyntaxError

// 模拟一个超大的数据库 ID
const databaseIdString = "9007199254740991001"; // 大于 MAX_SAFE_INTEGER

// ❌ 错误处理：精度丢失
const wrongId = Number(databaseIdString);
console.log(wrongId); // 9007199254740991000 (最后一位变成了0！)

// ✅ 正确处理：使用 BigInt
const correctId = BigInt(databaseIdString);
console.log(correctId); // 9007199254740991001n

const data = {
  id: 123456789012345678901n,
  name: "Test User"
};

// ❌ 直接序列化会报错
try {
  // JSON.stringify(data); // TypeError: Do not know how to serialize a BigInt
} catch (e) {
  console.log("序列化出错：", e.message);
}

// ✅ 解决方案 1：定义 toJSON 方法
BigInt.prototype.toJSON = function() { 
  return this.toString(); 
};
// 注意：修改原型要谨慎，全局修改可能影响其他库

// ✅ 解决方案 2：使用 replacer 函数（推荐）
const jsonStr = JSON.stringify(data, (key, value) =>
  typeof value === ‘bigint‘ ? value.toString() : value
);

console.log(jsonStr); 
// 输出: {"id":"123456789012345678901","name":"Test User"}

// 反序列化：将字符串还原为 BigInt
const parsedData = JSON.parse(jsonStr, (key, value) => {
  // 如果匹配数字字符串且很大，你可以选择转回 BigInt
  // 这里为了演示简单，判断特定 key
  if (key === ‘id‘) return BigInt(value);
  return value;
});

console.log(parsedData.id); 
// 输出: 123456789012345678901n

// ❌ 以下操作都是非法的
Math.max(1n, 2n);
Math.sqrt(4n);