JavaScript中如何表示任意长度整数？含π计算报错问题

我尝试使用以下公式在JavaScript中计算π到n位小数：

#!/usr/bin/env js60
function calculatePi(n) {
    var q = t = k = 1
    var m = x = 3
    var n = n + 1
    var r = 0
    str = ''
    while (str.length < n) {
        if (4 * q + r - t < m * t) {
            str += m
            var rr = r
            r = 10 * (r - m * t)
            m = Math.floor((10 * (3 * q + rr)) / t - 10 * m)
            q = 10 * q
        } else {
            m = Math.floor(((q * (7 * k + 2)) + (r * x)) / (t * x))
            r = ((2 * q) + r) * x
            t = t * x
            q = q * k
            k = k + 1
            x = x + 2
        }
    }
    return str.slice(0, 1) + '.' + str.slice(1)
}
print(calculatePi(19))

该代码在支持任意长度整数的语言中可正常运行，但在JavaScript中仅能生成前18位正确的π值，超过后数值过大无法处理；若传入大数值如10000，还会进入无限循环。我尝试按照建议使用后缀n定义大整数：var a = 1000000000000000000000000000n，却出现错误：

typein:1:8 SyntaxError: identifier starts immediately after numeric literal:
typein:1:8 var a = 1000000000000000000000000000n
typein:1:8 ........^

请问在JavaScript中如何正确表示任意长度的整数？

问题根源分析 #

你的代码遇到两个核心问题：

1. Number类型的精度瓶颈：JavaScript原生Number是64位浮点数，仅能精确表示到2^53（约9e15），超过这个阈值的整数会丢失精度，导致π的计算结果在18位后失真，甚至触发无限循环。
2. BigInt语法不兼容旧环境：你使用的js60是旧版本的SpiderMonkey引擎（对应Firefox 60），而BigInt是ES2020才引入的特性，这个版本的引擎完全不支持该语法，因此抛出了语法错误。

解决方案一：现代JS环境+BigInt（推荐） #

如果能升级到支持ES2020+的环境（比如最新版Node.js、Chrome/Edge/Firefox，或更新的SpiderMonkey引擎），BigInt就是处理任意长度整数的最优解。

正确的BigInt写法 #

BigInt的标准写法是数字直接紧跟小写字母n，不能有空格，示例：

const bigNum = 1000000000000000000000000000n; // 正确
// const badNum = 1000000000000000000000000000 n; // 错误，空格会被解析为标识符

修改后的高精度π计算代码 #

把原代码中所有数值变量替换为BigInt类型，同时注意：

• 不能用Math.floor()处理BigInt，直接用BigInt的除法（自动截断取整）
• 所有运算必须在BigInt之间进行，避免隐式类型转换

修改后的代码：

function calculatePi(n) {
    let q = t = k = 1n;
    let m = x = 3n;
    const targetLength = BigInt(n) + 1n;
    let r = 0n;
    let str = '';
    while (str.length < targetLength) {
        if (4n * q + r - t < m * t) {
            str += m.toString();
            const rr = r;
            r = 10n * (r - m * t);
            m = (10n * (3n * q + rr)) / t - 10n * m;
            q = 10n * q;
        } else {
            m = ((q * (7n * k + 2n)) + (r * x)) / (t * x);
            r = ((2n * q) + r) * x;
            t = t * x;
            q = q * k;
            k = k + 1n;
            x = x + 2n;
        }
    }
    return str.slice(0, 1) + '.' + str.slice(1);
}

// 测试：计算100位π
console.log(calculatePi(100));

这个版本可以轻松计算上万位的π，不会出现精度丢失或无限循环问题。

解决方案二：旧环境中模拟大整数运算 #

如果必须在不支持BigInt的旧环境（如js60）运行，你需要用字符串或数组手动模拟大整数的加减乘除运算。这会比较繁琐，举个大整数乘法的示例：

// 模拟两个大整数（字符串形式）的乘法
function bigMultiply(aStr, bStr) {
    const result = Array(aStr.length + bStr.length).fill(0);
    for (let i = aStr.length - 1; i >= 0; i--) {
        for (let j = bStr.length - 1; j >= 0; j--) {
            const product = (aStr[i] - '0') * (bStr[j] - '0');
            const sum = product + result[i + j + 1];
            result[i + j] += Math.floor(sum / 10);
            result[i + j + 1] = sum % 10;
        }
    }
    // 去掉前导零
    while (result[0] === 0) result.shift();
    return result.length === 0 ? '0' : result.join('');
}

你需要把原代码中的所有整数运算都替换为这类模拟函数，才能在旧环境实现高精度计算。但这种方法效率低、维护成本高，优先推荐升级到现代JS环境。

内容的提问来源于stack exchange，提问作者15 Volts