前端大数字精度解决：big.js的教程和原理解析

作者鹏多多

2025年12月22日 08:08

在前端开发中，处理金融、电商等领域的数字计算时，JavaScript 原生的 Number 类型因采用 64 位双精度浮点数存储，极易出现精度丢失问题（如 0.1 + 0.2 !== 0.3）。big.js 作为轻量级的大数处理库，以简洁的 API 和清晰的源码逻辑，成为解决该问题的主流选择。本文将从 API 用法和源码原理两方面，全面解析 big.js 的核心价值。

1. 核心特性

big.js 专为高精度十进制计算设计，核心特点：

轻量（仅 ~6KB 无依赖）；
不可变设计（所有操作返回新实例）；
可配置精度、舍入模式；
兼容所有主流浏览器和 Node.js。

2. 常用和特殊API详解

2.1. 基础初始化 API

big.js 的核心是 Big 构造函数，用于创建大数实例，支持多种入参类型：

import Big from 'big.js';

// 1. 基础初始化（支持数字、字符串、Big 实例）
const num1 = new Big(123); // 数字
const num2 = new Big('123.4567890123456789'); // 字符串（推荐，避免精度丢失）
const num3 = new Big(num2); // 基于已有 Big 实例创建

// 2. 特殊值初始化
const zero = new Big(0); // 0
const negative = new Big('-987654321.987654321'); // 负数
const scientific = new Big('1.23e+5'); // 科学计数法

注意：初始化时优先使用字符串入参，避免数字本身已因浮点数存储丢失精度。

2.2. 常用计算 API

big.js 提供了完整的算术运算方法，所有方法均返回新的 Big 实例（原实例不变）：

API 方法	作用	示例
`plus(n)`	加法	`new Big(0.1).plus(0.2).toString()` → "0.3"
`minus(n)`	减法	`new Big(1).minus(0.9).toString()` → "0.1"
`times(n)`	乘法	`new Big(2).times(0.1).toString()` → "0.2"
`div(n)`	除法	`new Big(1).div(3).toString()` → "0.3333333333"
`mod(n)`	取模	`new Big(5).mod(2).toString()` → "1"
`pow(n)`	幂运算	`new Big(10).pow(3).toString()` → "1000"

示例代码：

// 高精度加法
const a = new Big('0.1');
const b = new Big('0.2');
const sum = a.plus(b);
console.log(sum.toString()); // "0.3"

// 高精度除法（默认精度 10 位）
const c = new Big('1');
const d = new Big('3');
const div = c.div(d);
console.log(div.toString()); // "0.3333333333"

2.3. 特殊配置 & 工具 API

2.3.1. 全局配置 API

big.js 支持全局配置精度和舍入模式，核心配置项：

// 1. 设置全局精度（小数点后位数），默认 20
Big.DP = 15; 

// 2. 设置舍入模式，默认 ROUND_HALF_UP（四舍五入）
Big.RM = Big.roundHalfUp; 

// 舍入模式枚举（常用）：
// Big.roundUp: 向上取整
// Big.roundDown: 向下取整
// Big.roundHalfEven: 银行家舍入（四舍六入五取偶）

2.3.2. 实例工具 API

API 方法	作用	示例
`toString()`	转为字符串	`new Big(123.45).toString()` → "123.45"
`toFixed(dp)`	固定小数位数	`new Big(1.234).toFixed(2)` → "1.23"
`toPrecision(pre)`	固定有效数字	`new Big(123.45).toPrecision(3)` → "123"
`cmp(n)`	比较大小（-1/0/1）	`new Big(5).cmp(3)` → 1
`abs()`	绝对值	`new Big(-123).abs()` → Big { s: 1, e: 2, c: [1,2,3] }
`neg()`	取反	`new Big(123).neg()` → Big { s: -1, e: 2, c: [1,2,3] }
`isZero()`	判断是否为 0	`new Big(0).isZero()` → true
`isNegative()`	判断是否为负数	`new Big(-1).isNegative()` → true

示例代码：

// 配置精度和舍入模式
Big.DP = 2;
Big.RM = Big.roundUp;

// 向上取整的除法
const num = new Big('1').div('3');
console.log(num.toString()); // "0.34"

// 比较大小
const x = new Big(10);
const y = new Big(5);
console.log(x.cmp(y)); // 1（x > y）
console.log(x.cmp(x)); // 0（相等）
console.log(y.cmp(x)); // -1（y < x）

3. 源码解析

big.js 解决精度问题的核心思路是：将数字转为字符串拆分存储，通过模拟手工计算的方式实现算术运算，而非依赖 JavaScript 原生的浮点数运算。

3.1. 核心数据结构

Big 实例的内部存储结构（核心属性）：

// 以 new Big('123.456') 为例
{
  s: 1,        // 符号位：1 正数，-1 负数
  e: 2,        // 指数：小数点偏移量（整数部分的位数 - 1），123.456 的整数部分是 123（3 位），故 e = 3-1 = 2
  c: [1,2,3,4,5,6] // 系数数组：存储数字的每一位（无小数点，通过 e 定位）
}

符号位 s：分离正负，避免运算时处理符号干扰；
指数 e：记录小数点位置，将小数转为“整数 + 指数”的形式；
系数数组 c：以数组存储每一位数字，彻底规避浮点数的二进制存储精度丢失。

3.2. 核心原理：从“二进制浮点”到“十进制手工计算”

JavaScript 原生精度丢失的根源是：十进制小数无法被二进制浮点数精确表示（如 0.1 的二进制是无限循环小数）。big.js 则回归“手工计算逻辑”，步骤如下：

步骤 1：初始化时的字符串解析

当传入数字/字符串时，big.js 会先将其转为字符串，逐字符解析为 s/e/c：

// 源码核心解析逻辑（简化版）
function parse(str) {
  let s = 1;
  let e = 0;
  let c = [];

  // 1. 处理符号
  if (str[0] === '-') {
    s = -1;
    str = str.slice(1);
  }

  // 2. 处理小数点
  const dotIndex = str.indexOf('.');
  if (dotIndex !== -1) {
    e = dotIndex - (str.length - 1); // 计算指数偏移
    str = str.replace('.', ''); // 移除小数点
  }

  // 3. 解析每一位到系数数组
  for (let i = 0; i < str.length; i++) {
    c.push(Number(str[i]));
  }

  // 4. 去除前导零、调整指数
  // ...（源码中会处理前导零、末尾零等边界情况）

  return { s, e, c };
}

步骤 2：算术运算的“手工模拟”

以加法为例，big.js 模拟人类手工加法的“对齐小数点 → 逐位相加 → 处理进位”逻辑：

// 加法核心逻辑（简化版）
function add(a, b) {
  // 1. 对齐小数点（统一指数 e）
  let [x, y] = alignExponent(a, b); // 对齐后，x.e === y.e

  // 2. 逐位相加（从后往前）
  let carry = 0;
  const c = [];
  for (let i = x.c.length - 1; i >= 0; i--) {
    const sum = x.c[i] + y.c[i] + carry;
    c.unshift(sum % 10); // 当前位
    carry = Math.floor(sum / 10); // 进位
  }

  // 3. 处理最后一位进位
  if (carry) c.unshift(carry);

  // 4. 构建新的 Big 实例
  return new Big({ s: a.s, e: x.e, c });
}

// 对齐指数的辅助函数
function alignExponent(a, b) {
  const diff = a.e - b.e;
  if (diff > 0) {
    // a 的指数更大，给 b 的系数数组补零（相当于小数点右移）
    b.c = b.c.concat(Array(diff).fill(0));
    b.e = a.e;
  } else if (diff < 0) {
    // b 的指数更大，给 a 的系数数组补零
    a.c = a.c.concat(Array(-diff).fill(0));
    a.e = b.e;
  }
  return [a, b];
}

乘法、除法等运算的核心逻辑同理：

乘法：模拟“逐位相乘 → 错位相加 → 处理进位”；
除法：模拟“试商 → 求余 → 补零继续除”，直到达到配置的精度（DP）；
所有运算均基于十进制数字数组，而非二进制浮点数，从根源避免精度丢失。

步骤 3：舍入逻辑的精准控制

big.js 提供多种舍入模式，核心是通过判断“舍弃位的数字”决定是否进位，例如四舍五入（ROUND_HALF_UP）：

// 舍入核心逻辑（简化版）
function round(c, dp, rm) {
  const cutIndex = dp; // 保留位数的索引
  const discard = c[cutIndex]; // 舍弃位的数字

  if (rm === Big.roundHalfUp) {
    // 四舍五入：舍弃位 >=5 则进位
    if (discard >= 5) {
      carry(c, cutIndex - 1); // 向前一位进位
    }
    c.splice(cutIndex); // 截断舍弃位
  }
  return c;
}

3.3. 源码核心亮点

不可变设计：所有运算返回新实例，原实例不修改，避免副作用；
最小化计算：仅处理必要的数字位，去除前导零、末尾零，提升性能；
可配置化：通过 DP（精度）、RM（舍入模式）适配不同业务场景；
轻量无依赖：核心代码仅千行左右，无外部依赖，易于集成。

4. 适用场景 & 注意事项

适用场景

金融计算（金额、税率、利息）；
电商价格计算（优惠券、折扣、满减）；
高精度数据展示（科学计算、统计报表）。

注意事项

初始化优先使用字符串，避免数字入参提前丢失精度；
避免频繁创建 Big 实例，可复用实例提升性能；
与原生 Number 互转时，需通过 toString() 或 toNumber() 方法，避免直接强制转换；
big.js 仅处理十进制大数，如需处理大整数（如 ID、雪花算法），可选择 bigint 或 bn.js。

5. 总结

big.js 作为前端大数精度处理的经典库，核心价值在于：

以字符串解析 + 十进制数组存储的方式，规避了 JavaScript 浮点数的二进制存储缺陷；
通过模拟手工计算的算术逻辑，实现高精度的加减乘除等运算；
提供简洁的 API 和可配置项，适配不同业务场景的精度需求。

在处理前端数字精度问题时，big.js 以轻量、易用、可靠的特性，成为开发者的首选方案。理解其 API 用法和源码原理，不仅能解决实际业务问题，也能深入理解 JavaScript 数字存储的底层逻辑。

本次分享就到这儿啦，我是鹏多多，深耕前端的技术创作者，如果您看了觉得有帮助，欢迎评论，关注，点赞，转发，我们下次见~

PS：在本页按F12，在console中输入document.getElementsByClassName('panel-btn')[0].click();有惊喜哦~

往期文章

普通视图