JavaScript 中大整数溢出与内存爆炸问题的解决方案-js教程-PHP中文网

JavaScript 中大整数溢出与内存爆炸问题的解决方案

本文详解如何应对 JavaScript 中因 mod 超过 2³² 导致的内存耗尽问题，介绍使用 BigInt 替代 Number、优化算法避免指数级数组膨胀、引入哈希缓存剪枝等核心策略，并提供可直接运行的修复代码。

本文详解如何应对 javascript 中因 `mod` 超过 2³² 导致的内存耗尽问题，介绍使用 `bigint` 替代 number、优化算法避免指数级数组膨胀、引入哈希缓存剪枝等核心策略，并提供可直接运行的修复代码。

你遇到的错误（如 Mark-sweep ... allocation failure）并非传统意义上的“整数溢出”，而是内存爆炸性增长引发的堆内存耗尽。关键问题在于：每次循环中，r、coef、cons 数组长度呈 2^j 指数级翻倍（j 为迭代次数）。当 iterations = 33 时，数组元素数量高达 2³³ ≈ 85 亿个——远超 V8 引擎可用内存，导致垃圾回收失败。

? 根本原因分析

mod 本身在 JavaScript 中作为 Number 类型，最大安全整数为 Number.MAX_SAFE_INTEGER = 2⁵³−1，因此 mod > 2³² 并不会直接导致数值错误，但：
mod *= 2 使 mod 快速增长（32 次后达 2³³），而更致命的是：
每轮循环中 newR.push(...) 等操作将每个输入元素无条件扩展为两个新元素，导致三组数组长度从 1 → 2 → 4 → 8 → … → 2^count。
内存占用 ≈ O(3 × 2^count × sizeof(number))，32 次即需数 GB 内存，V8 无法回收。

✅ 正确解决方案（非简单换语言）

1. 使用 `BigInt` 安全处理大模数（必要但不充分）

function run(vals, count) {
  let total = 0.5;
  let { r, coef, cons, mod } = {
    r: [1n],           // ← 全部转为 BigInt
    coef: [3n],
    cons: [1n],
    mod: 2n
  };

  const startTime = performance.now();

  for (let j = 0; j = mod) {
          newR.push(r[i], r[i] + mod);
          newCoef.push(coef[i], coef[i]);
          newCons.push(cons[i], cons[i]);
        } else {
          total += 1 / Number(mod); // 仅此处需转 number 用于浮点累加
        }
      } else {
        newR.push(r[i], r[i] + mod);
        newCoef.push(3n * coef[i], 3n * coef[i]);
        newCons.push(3n * cons[i] + mod / 2n, 3n * cons[i] + mod / 2n);
      }
    }

    [r, coef, cons] = [newR, newCoef, newCons];
    mod *= 2n; // BigInt 乘法
  }

  const endTime = performance.now();
  return { total: total * 100, executionTime: (endTime - startTime).toFixed(2) };
}

⚠️ 注意：BigInt 解决了模运算精度问题，但未缓解内存爆炸——数组仍指数增长。

2. 关键优化：用状态映射替代数组膨胀（推荐）

观察逻辑：每轮实际只关心 (r[i], coef[i], cons[i]) 三元组在模 mod 下的行为。大量三元组本质重复（如 r[i] % mod 相同且系数一致），可用 Map 去重聚合：

Java Maven Code Review

审查Java Maven项目（ZIP压缩包或GitLab仓库URL），检查代码规范、命名、模块边界、可维护性问题以及重复代码。

下载

function runOptimized(vals, count) {
  // 状态表示：{ rMod: BigInt, coef: BigInt, cons: BigInt } → count
  let stateMap = new Map();
  stateMap.set(JSON.stringify({ r: 1n, coef: 3n, cons: 1n }), 1n);
  let mod = 2n;
  let total = 0.5;

  for (let j = 0; j = mod) {
          // 分裂为两个等价状态，权重继承
          const key1 = JSON.stringify({ r, coef, cons });
          const key2 = JSON.stringify({ r: r + mod, coef, cons });
          nextMap.set(key1, (nextMap.get(key1) || 0n) + weight);
          nextMap.set(key2, (nextMap.get(key2) || 0n) + weight);
        } else {
          total += Number(weight) / Number(mod);
        }
      } else {
        const key1 = JSON.stringify({ r, coef: 3n * coef, cons: 3n * cons + mod / 2n });
        const key2 = JSON.stringify({ r: r + mod, coef: 3n * coef, cons: 3n * cons + mod / 2n });
        nextMap.set(key1, (nextMap.get(key1) || 0n) + weight);
        nextMap.set(key2, (nextMap.get(key2) || 0n) + weight);
      }
    }

    stateMap = nextMap;
    mod *= 2n;
  }

  return { total: total * 100, executionTime: 0 }; // 实际可加计时
}