big.js与bignumber.js的差异、统一配置与避坑技巧完全指南

// 引入库
import Big from 'big.js';
import BigNumber from 'bignumber.js';
// --------------------------
// big.js 配置（对齐核心规则）
// --------------------------
Big.DP = 20; // 小数位上限设为20（匹配bignumber.js默认）
Big.RM = Big.roundHalfUp; // 显式指定四舍五入（默认值，可省略）
Big.EXP = 0; // 禁用科学计数法，始终常规显示
Big.PE = 0; // 精度误差阈值（默认0，无需改）
// --------------------------
// bignumber.js 配置（对齐big.js严格性）
// --------------------------
BigNumber.config({
DECIMAL_PLACES: 20, // 小数位上限20
ROUNDING_MODE: BigNumber.ROUND_HALF_UP, // 四舍五入
EXPONENTIAL_AT: [-Infinity, Infinity], // 禁用科学计数法
ALLOW_NAN: false, // 禁用NaN，非法值直接报错（匹配big.js）
ALLOW_INFINITY: false, // 禁用Infinity，匹配big.js
PRECISION: 20, // 有效数字精度20（与DECIMAL_PLACES配合）
});

const num = '1.235'; // 经典四舍五入场景
// big.js 计算
const bigResult = new Big(num).dp(2, Big.roundHalfUp).toString();
// 结果："1.24"
// bignumber.js 计算
const bnResult = new BigNumber(num).decimalPlaces(2, BigNumber.ROUND_HALF_UP).toString();
// 结果："1.24"（与big.js一致）

const divisor = '3';
// big.js 计算（手动指定20位小数）
const bigDiv = new Big('1').div(divisor).dp(20, Big.roundHalfUp).toString();
// 结果："0.33333333333333333333"
// bignumber.js 计算（自动截断+手动确认）
const bnDiv = new BigNumber('1').div(divisor).decimalPlaces(20, BigNumber.ROUND_HALF_UP).toString();
// 结果："0.33333333333333333333"（与big.js一致）

const bigNum = '1000000000000000000000'; // 1e21
// big.js 显示
new Big(bigNum).toString(); // "1000000000000000000000"
// bignumber.js 显示（配置后）
new BigNumber(bigNum).toString(); // "1000000000000000000000"（无科学计数法）

/**
* 校验数值是否为合法的可转换数字
* @param {*} value 输入值
* @returns {boolean} 是否合法
*/
function isValidNumber(value) {
    // 排除空值、非字符串/数字类型
    if (value === null || value === undefined || typeof value === 'boolean') {
        return false
    }
    // 转字符串后去除首尾空格，排除空字符串
    const strValue = String(value).trim()
    if (strValue === '') {
        return false
    }
    // 正则校验：仅允许数字、小数点（最多一个）、正负号（仅开头）
    const numReg = /^[-+]?(\d+(\.\d*)?|\.\d+)$/
    if (!numReg.test(strValue)) {
        return false
    }
    // 校验极值：避免超出安全范围（可根据业务调整）
    const num = Number(strValue)
    if (isNaN(num) || !isFinite(num)) {
        return false
    }
    return true
}
/**
* 安全创建 Big/bignumber 实例
* @param {*} value 输入值
* @param {string} lib 库类型：'big.js' | 'bignumber.js'
* @returns {Big | BigNumber | null} 实例或null（失败时）
*/
function safeCreateInstance(value, lib = 'big.js') {
    try {
        if (!isValidNumber(value)) {
            console.warn(`非法值：${value}，无法转换为高精度数字`)
            return null
        }
        const strValue = String(value).trim()
        return lib === 'big.js' ? new Big(strValue) : new BigNumber(strValue)
    } catch (error) {
        console.error(`创建高精度数字失败：${error.message}`)
        return null
    }
}
/**
* 安全执行高精度运算（以加法为例）
* @param {*} a 第一个数
* @param {*} b 第二个数
* @param {string} lib 库类型
* @returns {string | null} 运算结果（字符串形式避免精度丢失）
*/
function safeAdd(a, b, lib = 'big.js') {
    const numA = safeCreateInstance(a, lib)
    const numB = safeCreateInstance(b, lib)
    if (!numA || !numB) return null
    return numA.plus(numB).toString()
}

const invalidValues = ['abc', '123a', '', null, undefined, true]
invalidValues.forEach((value) => {
    const bigInstance = safeCreateInstance(value, 'big.js')
    const bnInstance = safeCreateInstance(value, 'bignumber.js')
    console.log(`输入：${value}`)
    console.log('big.js 结果：', bigInstance || '非法值')
    console.log('bignumber.js 结果：', bnInstance || '非法值')
})
// 输出：所有非法值均返回"非法值"，无报错

// 测试用例：超大数、0/0运算
const extremeValues = ['1e+1000', '0.000000000000000000001', '0']
// 测试0/0（无效运算）
const a = safeCreateInstance('0')
const b = safeCreateInstance('0')
try {
    const result = a.div(b).toString()
} catch (error) {
    console.error('无效运算：', error.message) // 捕获"Division by zero"错误
}
// 测试超大数
const bigExtreme = safeCreateInstance('1e+1000', 'big.js')
if (bigExtreme) {
    console.log('big.js 处理超大数：', bigExtreme.dp(20).toString())
}