JavaScript中大数乘法的字符串实现与常见陷阱规避-js教程-PHP中文网

javascript中大数乘法的字符串实现与常见陷阱规避

本文深入探讨了在JavaScript中不使用`BigInt`进行大数乘法的字符串实现方法，重点关注了该过程中可能遇到的常见编程陷阱。通过分析变量作用域、函数副作用以及自动分号插入等问题，文章提供了清晰的解决方案和最佳实践，旨在帮助开发者编写更健壮、可维护的大数运算代码。

大数乘法：基于字符串的实现原理

在JavaScript中，由于Number.MAX_SAFE_INTEGER（即2^53 - 1）的限制，直接使用内置数字类型进行大数运算会导致精度丢失。因此，当需要处理超出此范围的整数乘法时，一种常见的策略是将数字表示为字符串，然后模拟小学数学中的“竖式乘法”过程。

大数乘法的基本思路可以分解为以下两步：

逐位乘法并生成部分积（Partial Products）：将较短数字的每一位与较长数字相乘，生成一系列部分积。每个部分积都需要根据其在乘数中的位置进行适当的补零。
部分积累加：将所有生成的部分积按位相加，处理进位，最终得到乘法结果。

例如，计算 "123" * "45"：

立即学习“Java免费学习笔记（深入）”；

  123
x  45
-----
  615  (123 * 5)
4920 (123 * 4, 补一位0)
-----
5535 (615 + 4920)

登录后复制

常见陷阱与最佳实践

在实现上述算法时，开发者常会遇到一些难以察觉的问题，尤其是在处理变量作用域和函数副作用方面。

1. 变量作用域：避免意外的全局状态污染

一个常见的问题是，当多个函数共享或修改同一个外部变量时，可能会导致数据混乱，尤其是在循环或迭代过程中。例如，在处理部分积累加时，如果进位变量被声明在外部作用域，并在每次累加操作中被意外地带入下一次操作，就会导致结果错误。

问题示例：假设有一个全局或外部作用域的进位变量 remCont2，用于在多个部分积相加时处理进位。如果每次 addSum 调用后 remCont2 的值没有被正确重置或局部化，那么前一次加法操作的进位可能会影响到下一次加法，导致结果偏离。

// 错误示例：remCont2 声明在外部作用域
let remCont2; // 外部声明，可能导致进位累积

function addSum(num1, num2) {
    let addTotal = '';
    // remCont2 在这里没有被初始化，可能继承了上次调用的值
    for (let i = num1.length - 1; i >= 0; i--) {
        let total2 = 0;
        // ... (省略部分计算逻辑)
        if (remCont2 > 0) { // 依赖外部 remCont2
            total2++;
        }
        remCont2 = 0; // 修改外部 remCont2
        // ...
    }
    // ...
}

登录后复制

最佳实践：

局部化变量：始终在变量被使用的最小作用域内声明它。对于函数内部的临时变量，如进位（carry），应在函数内部使用 let 或 const 声明，确保每次函数调用都有一个全新的、独立的变量实例。
避免隐式全局变量：JavaScript在非严格模式下允许不使用 var, let, const 声明变量，这会导致变量自动成为全局变量。这是一种非常糟糕的实践，应始终使用明确的声明关键字。在严格模式下 ("use strict")，这种行为会被阻止。

修正示例：

// 正确示例：将进位变量局部化到函数内部
function addSum(num1, num2) {
    let sumResult = '';
    let carry = 0; // 局部声明进位变量，每次调用都是新的
    let i = num1.length - 1;
    let j = num2.length - 1;

    while (i >= 0 || j >= 0 || carry > 0) {
        let digit1 = i >= 0 ? parseInt(num1[i--]) : 0;
        let digit2 = j >= 0 ? parseInt(num2[j--]) : 0;

        let currentSum = digit1 + digit2 + carry;
        sumResult = (currentSum % 10) + sumResult; // 将当前位添加到结果前面
        carry = Math.floor(currentSum / 10);
    }
    // 处理结果中的前导零，例如 "007" 应该变成 "7"
    return sumResult.replace(/^0+/, "") || "0";
}

登录后复制

2. 函数副作用：拥抱纯函数原则

函数副作用是指函数在执行过程中，除了返回一个值之外，还修改了其作用域之外的状态。虽然副作用在某些场景下不可避免，但在实现复杂逻辑时，过多的副作用会使代码难以理解、测试和维护。

腾讯智影-AI数字人

基于AI数字人能力，实现7*24小时AI数字人直播带货，低成本实现直播业务快速增增，全天智能在线直播

查看详情

问题示例：在原始代码中，addSum 函数不仅计算了两个数字字符串的和，还直接修改了外部的 addTotal 变量。

// 错误示例：addSum 具有副作用，修改外部 addTotal
let addTotal = ''; // 外部变量

function addSum(num1, num2) {
    addTotal = ''; // 每次调用都清空外部 addTotal，然后重新构建
    // ... 计算逻辑 ...
    // 最终结果存储在外部 addTotal 中
}

// 调用时，通过副作用累加结果
newArr.map(a => addPad(a)); // 这里的 map 实际上是利用副作用来累加

登录后复制

这种模式的问题在于：

可预测性差：函数的行为依赖于外部状态，使得其输出不再仅仅由输入决定。
难以测试：测试函数需要设置复杂的外部环境，并检查外部状态的变化。
复用性低：函数与特定外部变量紧密耦合，难以在其他上下文中使用。

最佳实践：

返回结果而非修改外部状态：让函数专注于接收输入、执行计算并返回结果。由调用者来决定如何处理这些结果。
构建纯函数：理想情况下，函数应该是一个纯函数：给定相同的输入，总是返回相同的输出，并且不产生任何可观察的副作用。

修正示例：结合上文的 addSum 修正，addPad 函数的调用逻辑也应相应调整，以累积 addSum 的返回值：

// 假设 addSum 已经是一个纯函数，返回两个数字字符串的和
// function addSum(num1, num2) { ... }

let finalSum = "0"; // 初始化累加器为 "0"
// 遍历部分积数组，并使用 addSum 累加结果
// 注意：这里使用 forEach 或 reduce 更合适，因为我们是在累积结果，而不是映射新数组
for (const partialProduct of newArr) {
    finalSum = addSum(finalSum, partialProduct);
}

return finalSum; // 返回最终累加结果

登录后复制

通过这种方式，addSum 变得更加独立和可预测，addPad（或者说处理累加的逻辑）也更加清晰地表达了其意图。

3. 显式分号：避免自动分号插入（ASI）的陷阱

JavaScript的自动分号插入（Automatic Semicolon Insertion, ASI）机制会在某些情况下自动插入分号。虽然这在一定程度上提供了便利，但也可能导致意料之外的行为，使代码难以调试。

最佳实践：

始终手动添加分号：为了代码的清晰性和一致性，建议在每个语句的末尾都显式添加分号。这有助于避免ASI可能带来的潜在问题，并使代码更易于阅读和维护。

综合考量：构建健壮的大数乘法函数

综合以上最佳实践，一个健壮的大数乘法函数应具备以下特点：

清晰的零值处理：任何一个乘数为 "0" 时，结果应直接返回 "0"。
标准化输入：确保输入数字字符串不含前导零（除非是 "0" 本身）。
模块化设计：将大数乘法分解为独立的子任务，如：
- multiplySingleDigit(numStr, digit): 一个大数字符串与一个单数字符串相乘。
- add(numStr1, numStr2): 两个大数字符串相加。
局部变量管理：所有临时变量，尤其是进位变量，都应在其作用域内声明。
纯函数优先：尽可能编写没有副作用的函数，通过返回值传递数据。

示例代码结构（概念性）

/**
 * 将两个大数（字符串形式）相乘
 * @param {string} num1 第一个乘数
 * @param {string} num2 第二个乘数
 * @returns {string} 乘法结果
 */
function multiply(num1, num2) {
    // 1. 处理特殊情况：任何一个乘数为 "0"
    if (num1 === "0" || num2 === "0") {
        return "0";
    }

    // 确保 num1 是较长的数，简化后续循环
    if (num1.length < num2.length) {
        [num1, num2] = [num2, num1]; // 交换
    }

    const partialProducts = []; // 存储所有部分积

    // 2. 逐位乘法并生成部分积
    for (let i = num2.length - 1; i >= 0; i--) {
        const digit2 = parseInt(num2[i]);
        let carry = 0;
        let currentPartialProduct = '';

        for (let j = num1.length - 1; j >= 0; j--) {
            const digit1 = parseInt(num1[j]);
            const product = digit1 * digit2 + carry;
            currentPartialProduct = (product % 10) + currentPartialProduct;
            carry = Math.floor(product / 10);
        }

        if (carry > 0) {
            currentPartialProduct = carry + currentPartialProduct;
        }

        // 补零
        partialProducts.push(currentPartialProduct + '0'.repeat(num2.length - 1 - i));
    }

    // 3. 部分积累加
    let finalSum = "0";
    for (const product of partialProducts) {
        finalSum = addStrings(finalSum, product); // 使用一个独立的加法函数
    }

    return finalSum;
}

/**
 * 将两个大数（字符串形式）相加
 * @param {string} num1 第一个加数
 * @param {string} num2 第二个加数
 * @returns {string} 加法结果
 */
function addStrings(num1, num2) {
    let sumResult = '';
    let carry = 0;
    let i = num1.length - 1;
    let j = num2.length - 1;

    while (i >= 0 || j >= 0 || carry > 0) {
        let digit1 = i >= 0 ? parseInt(num1[i--]) : 0;
        let digit2 = j >= 0 ? parseInt(num2[j--]) : 0;

        let currentSum = digit1 + digit2 + carry;
        sumResult = (currentSum % 10) + sumResult;
        carry = Math.floor(currentSum / 10);
    }
    return sumResult.replace(/^0+/, "") || "0"; // 移除前导零，如果结果是"0"则返回"0"
}

// 示例用法
console.log(multiply("51", "23")); // "1173"
console.log(multiply("9", "9"));   // "81"
console.log(multiply("311", "692")); // "215212"
console.log(multiply("1020303004875647366210", "2774537626200857473632627613"));
// 预期结果: "2830869077153280552556547081187254342445169156730"

登录后复制