【js】js高精度加减乘除函数

加法

/**
 * 高精度加法函数，处理字符串或数字输入，去除尾部多余的零
 * @param {string|number} a - 被加数
 * @param {string|number} b - 加数
 * @returns {string} - 计算结果，去除尾部多余的零
 */
export const add = (a, b) => {
    // 将输入转换为字符串
    a = typeof a === 'number' ? a.toString() : a;
    b = typeof b === 'number' ? b.toString() : b;
    // 分割整数部分和小数部分
    let [intA = '0', decA = '0'] = a.split('.');
    let [intB = '0', decB = '0'] = b.split('.');
    // 去除小数部分可能为空的情况
    decA = decA || '0';
    decB = decB || '0';
    // 将小数部分补齐到相同长度
    const maxDecLen = Math.max(decA.length, decB.length);
    decA = decA.padEnd(maxDecLen, '0');
    decB = decB.padEnd(maxDecLen, '0');
    // 初始化进位
    let carry = 0;
    let resultDec = '';
    // 从小数部分开始逐位相加
    for (let i = maxDecLen - 1; i >= 0; i--) {
        let sum = parseInt(decA[i]) + parseInt(decB[i]) + carry;
        carry = Math.floor(sum / 10);
        resultDec = (sum % 10) + resultDec;
    }
    // 处理整数部分
    let resultInt = '';
    intA = intA.padStart(Math.max(intA.length, intB.length), '0');
    intB = intB.padStart(Math.max(intA.length, intB.length), '0');
    // 从整数部分开始逐位相加
    for (let i = intA.length - 1; i >= 0; i--) {
        let sum = parseInt(intA[i]) + parseInt(intB[i]) + carry;
        carry = Math.floor(sum / 10);
        resultInt = (sum % 10) + resultInt;
    }
    // 如果还有进位，添加到结果的开头
    if (carry) resultInt = carry + resultInt;
    // 去除结果整数部分的前导零
    resultInt = resultInt.replace(/^0+/, '');
    if (resultInt === '') resultInt = '0';
    // 拼接结果，处理小数部分尾部多余的零
    let result = resultInt + (resultDec !== '0' ? '.' + resultDec.replace(/0+$/, '') : '');
    return result;
};

减法

/**
 * 高精度减法函数，处理字符串或数字输入，去除尾部多余的零
 * @param {string|number} a - 被减数
 * @param {string|number} b - 减数
 * @returns {string} - 计算结果，去除尾部多余的零
 */
export const subtract = (a, b) => {
    // 将输入转换为字符串
    a = typeof a === 'number' ? a.toString() : a;
    b = typeof b === 'number' ? b.toString() : b;
    // 分割整数部分和小数部分
    let [intA = '0', decA = '0'] = a.split('.');
    let [intB = '0', decB = '0'] = b.split('.');
    // 去除小数部分可能为空的情况
    decA = decA || '0';
    decB = decB || '0';
    // 将小数部分补齐到相同长度
    const maxDecLen = Math.max(decA.length, decB.length);
    decA = decA.padEnd(maxDecLen, '0');
    decB = decB.padEnd(maxDecLen, '0');
    // 初始化借位
    let borrow = 0;
    let resultDec = '';
    // 从小数部分开始逐位相减
    for (let i = maxDecLen - 1; i >= 0; i--) {
        let diff = parseInt(decA[i]) - parseInt(decB[i]) - borrow;
        if (diff < 0) {
            diff += 10;
            borrow = 1;
        } else {
            borrow = 0;
        }
        resultDec = diff + resultDec;
    }
    // 处理整数部分
    let resultInt = '';
    intA = intA.padStart(Math.max(intA.length, intB.length), '0');
    intB = intB.padStart(Math.max(intA.length, intB.length), '0');
    // 从整数部分开始逐位相减
    for (let i = intA.length - 1; i >= 0; i--) {
        let diff = parseInt(intA[i]) - parseInt(intB[i]) - borrow;
        if (diff < 0) {
            diff += 10;
            borrow = 1;
        } else {
            borrow = 0;
        }
        resultInt = diff + resultInt;
    }
    // 去除结果整数部分的前导零
    resultInt = resultInt.replace(/^0+/, '');
    if (resultInt === '') resultInt = '0';
    // 拼接结果，处理小数部分尾部多余的零
    let result = resultInt + (resultDec !== '0' ? '.' + resultDec.replace(/0+$/, '') : '');
    return result;
};

乘法

/**
 * 高精度乘法函数，处理字符串或数字输入，去除尾部多余的零
 * @param {string|number} a - 乘数
 * @param {string|number} b - 被乘数
 * @returns {string} - 计算结果，去除尾部多余的零
 */
const multiply = (a, b) => {
    a = typeof a === 'number' ? a.toString() : a;
    b = typeof b === 'number' ? b.toString() : b;
    let [intA, decA] = a.split('.');
    let [intB, decB] = b.split('.');
    decA = decA || '0';
    decB = decB || '0';
    const totalDecLen = decA.length + decB.length;
    const intPartA = intA + decA;
    const intPartB = intB + decB;
    let result = Array(intPartA.length + intPartB.length).fill(0);
    for (let i = intPartA.length - 1; i >= 0; i--) {
        for (let j = intPartB.length - 1; j >= 0; j--) {
            let product = parseInt(intPartA[i]) * parseInt(intPartB[j]) + result[i + j + 1];
            result[i + j + 1] = product % 10;
            result[i + j] += Math.floor(product / 10);
        }
    }
    result = result.join('').replace(/^0+/, '');
    if (totalDecLen > 0) {
        const integerLen = result.length - totalDecLen;
        if (integerLen <= 0) {
            result = '0.' + '0'.repeat(-integerLen) + result;
        } else {
            result = result.slice(0, integerLen) + '.' + result.slice(integerLen);
        }
        result = result.replace(/(\.[0-9]*?)0+$/, '$1').replace(/\.$/, '');
    } else {
        result = result || '0';
    }
    return result;
};

除法

/**
 * 高精度除法函数，处理字符串或数字输入，去除尾部多余的零
 * @param {string|number} dividend - 被除数
 * @param {string|number} divisor - 除数
 * @param {number} precision - 结果保留的小数位数，默认为 28
 * @returns {string} - 计算结果，去除尾部多余的零
 */
export const highPrecisionDivision = (dividend, divisor, precision = 28) => {
    const dividendStr = String(dividend);
    const divisorStr = String(divisor);
    let [dividendInt = '0', dividendDec = ''] = dividendStr.split('.');
    let [divisorInt = '0', divisorDec = ''] = divisorStr.split('.');
    const maxDecLength = Math.max(dividendDec.length, divisorDec.length, precision);
    dividendDec = dividendDec.padEnd(maxDecLength, '0');
    divisorDec = divisorDec.padEnd(maxDecLength, '0');
    const dividendFull = dividendInt + '.' + dividendDec;
    const divisorFull = divisorInt + '.' + divisorDec;
    const bigDividend = parseFloat(dividendFull);
    const bigDivisor = parseFloat(divisorFull);
    let result = (bigDividend / bigDivisor).toFixed(precision);
    // 去除尾部多余的零
    result = result.replace(/\.?0+$/, '');
    return result;
};

add(0.1, "0.3") // 0.4
add(0.1, 0.3) // 0.4
add(0.1687486415614614, 0.3) // 0.4687486415614614
add("5614", "999999999999999991454444444444444444444444444444") // 999999999999999991454444444444444444444444450058


subtract("5", "3") // 2
subtract(123.45, "67.89") // 55.56
subtract('561456.514614', "679") // 560777.514614
subtract("1000000000000000000000000000000", "1") // 999999999999999999999999999999


multiply("123", "456") // 56088
multiply(0.52, "67.89") // 35.3028
multiply(0.548568482, "0.5688974989") // 0.3120792373851696698
multiply("1000000000000000000000000000000", "1") // 1000000000000000000000000000000


highPrecisionDivision(10,2) // 5
highPrecisionDivision(0.456,0.00458) // 0.1249999988609375028980608135
highPrecisionDivision('0.456',0.08) // 0.1249999988609375028980608135
highPrecisionDivision(42424,424732545354332543543) // 0.0000000000000000998840339975