前端big.js解决大数字精度问题的使用教程和原理解析

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'); // 科学计数法

// 高精度加法
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"

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

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

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

// 配置精度和舍入模式
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）

// 以 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 定位）
}

// 源码核心解析逻辑（简化版）
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 };
}

// 加法核心逻辑（简化版）
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];
}

// 舍入核心逻辑（简化版）
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;
}