JavaScript 10进制大整数四则运算：加 减 乘 除

最新推荐文章于 2025-06-23 16:14:55 发布
原创 最新推荐文章于 2025-06-23 16:14:55 发布 · 594 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 

var digits = [
        '0', '1', '2', '3', '4', '5',
        '6', '7', '8', '9', 'a', 'b',
        'c', 'd', 'e', 'f', 'g', 'h',
        'i', 'j', 'k', 'l', 'm', 'n',
        'o', 'p', 'q', 'r', 's', 't',
        'u', 'v', 'w', 'x', 'y', 'z'
    ];

    var digitsMap = new Map();
    for (var i = 0; i < len(digits); i++) {
        digitsMap.set(digits[i], i);
    }


    function charCode(s, i) {
        if (isNumber(i) && strNonEmpty(s)) {
            return s.charCodeAt(i);
        }
        throw new Error("First param string and second param integer!");
    }
    function toLowerCase(s) {
        if (strNonEmpty(s)) {
            return s.toLowerCase();
        }
        throw new Error("First param string!");
    }
    function toUpperCase(s) {
        if (strNonEmpty(s)) {
            return s.toUpperCase();
        }
        throw new Error("First param string!");
    }

    function parseInt10(i) {
        if (isNumber(i)) {
            return Math.floor(i);
        }
        else {
            return parseInt(i);
        }
    }

    var numRegExp = /^[+-]?(0[box]?)?\w*$/;

    function checkRadixAndNumber(s, radix) {
        if ((lt(radix, 2) || gt(radix, 36)) && numRegExp.test(s)) {
            throw new Error("Radix between 2 and 36.");
        }
        s = toLowerCase(s);
        var sign = '+';
        if (eq(s.charAt(0), '-')) {
            sign = '-';
            s = s.substring(1);
        } else if (eq(s.charAt(0), '+')) {
            // sign = '+';
            s = s.substring(1);
        }

        if (eq(s.charAt(0), '0')) {
            radix = 8;
            s = s.substring(1);
            if (eq(s.charAt(0), 'o')) {
                // radix = 8;
                s = s.substring(1);
            }
            else if (eq(s.charAt(0), 'x')) {
                radix = 16;
                s = s.substring(1);
            } else if (eq(s.charAt(0), 'b')) {
                radix = 2;
                s = s.substring(1);
            }
        }

        for (var i = 0; i < len(s); i++) {
            if (nlt(digitsMap.get(s.charAt(i)), radix)) {
                throw new Error("Input number cannot greater than radix: " + radix);
            }
        }
        // for (var i = 0; i < len(s); i++) {
        //     if (!eq(s.charAt(i), '0')) {
        //         s = s.substring(i);
        //         break;
        //     }
        // }
        s = str2ListBySeparator(s, '');
        s = clearOpenZeroI(s);
        return [list2StrWithJoint(s, ''), radix, sign];
    }

    function checkBigIntegerNumber10(a) {
        if (oExist(a) && oExist(a.length)) {
            for (var i = 0; i < len(a); i++) {
                if (!((a[i] >= 0 && a[i] <= 9) || (a[i] >= '0' && a[i] <= '9'))) {
                    throw "Not a integer number string."
                }
            }
        } else {
            throw "Not a integer number string.";
        }
    }

    function initZero(nums) {
        for (var i = 0; i < len(nums); i++) {
            nums[i] = 0;
        }
    }

    function clearOpenZeroI(nums) {
        var openZero = 0;
        while (eq(nums[openZero], 0)) {
            openZero++;
        }
        nums = nums.slice(openZero);
        if (eq(len(nums), 0)) {
            nums = [0];
        }
        return nums;
    }

    function clearOpenZeroS(nums) {
        var openZero = 0;
        while (eq(nums[openZero], '0')) {
            openZero++;
        }
        nums = nums.slice(openZero);
        if (eq(len(nums), 0)) {
            nums = '0';
        }
        return nums;
    }

    var int10RegExp = /^[+-]?\d*$/;

    function whatSign(s) {
        return s.startsWith('-') ? '-' : '+';
    }

    function getRidOfSign(s) {
        if (eq(s.charAt(0), '-')) {
            s = s.substring(1);
        } else if (eq(s.charAt(0), '+')) {
            s = s.substring(1);
        }
        return s;
    }

    /**
     * 
     * @param {String} a 
     * @param {String} b 
     */
    function addInt10(a, b) {
        //check decimal format
        if (!(int10RegExp.test(a) && int10RegExp.test(b))) {
            throw new Error("params must be decimal number and sign only one +/-!");
        }
        //calc sign
        var asign = whatSign(a);
        var bsign = whatSign(b);

        a = getRidOfSign(a);
        b = getRidOfSign(b);


        checkBigIntegerNumber10(a);
        checkBigIntegerNumber10(b);

        a = clearOpenZeroS(a);
        b = clearOpenZeroS(b);

        //determine end sign
        if (eqInt10(a, b) && !eq(asign, bsign)) {
            return '0';
        }
        else if (ltInt10(a, b)) {//a > b ,indeed
            var tmp = a;//data swap
            a = b;
            b = tmp;
            tmp = bsign;//sign swap
            bsign = asign;
            asign = tmp;
        }
        var finalSign = asign;

        var radix = 10;
        var nums = EMPTY_VALUES.ARRAY;
        var le = pmax(a, b);
        nums.length = le + 1;
        initZero(nums);
        var i = len(a) - 1;
        var j = len(b) - 1;
        var k = 0;
        //core 1
        while (i >= 0 && j >= 0) {
            if (eq(asign, bsign)) {//for +
                nums[k++] = parseInt10(a[i--]) + parseInt10(b[j--]);
            } else {//for -
                nums[k++] = parseInt10(a[i--]) - parseInt10(b[j--]);
            }
        }
        while (i >= 0) {
            nums[k++] = parseInt10(a[i--]);
        }
        // while (j >= 0) {//this is error,max num rest!!!Do you understand?!!!
        //     nums[k++] = parseInt10(b[j--]);
        // }

        // core 2
        for (var n = 0; n < len(nums); n++) {
            if (eq(asign, bsign)) {//+ handler
                if (nums[n] >= radix) {
                    nums[n + 1] += parseInt10(nums[n] / radix);
                    nums[n] %= radix;
                }
            } else {//- handler
                if (nums[n] < 0) {//because of '-',don't have num >= radix;
                    nums[n + 1] -= 1;
                    nums[n] += radix;
                }
            }

        }
        nums.reverse();
        nums = clearOpenZeroI(nums);
        var s = list2StrWithJoint(nums, '');
        if (eq(finalSign, '-')) {
            s = '-' + s;
        }
        return s;
    }

    function multiplyInt10(a, b) {

        if (!(int10RegExp.test(a) && int10RegExp.test(b))) {
            throw new Error("params must be decimal number and sign only one +/-!");
        }

        //calc sign
        var asign = whatSign(a);
        var bsign = whatSign(b);

        a = getRidOfSign(a);
        b = getRidOfSign(b);

        checkBigIntegerNumber10(a);
        checkBigIntegerNumber10(b);

        a = clearOpenZeroS(a);
        b = clearOpenZeroS(b);

        var finalSign = eq(asign, bsign) ? '+' : '-';

        var radix = 10;
        var nums = EMPTY_VALUES.ARRAY;
        var le = pmax(a, b);
        nums.length = le * 2 + 1;
        initZero(nums);
        //core 1
        var k = 0;
        for (var i = len(a) - 1; i >= 0; i--) {
            for (var j = len(b) - 1; j >= 0; j--) {
                nums[len(a) - 1 - i + k++] += parseInt10(a[i]) * parseInt10(b[j]);
                // console.log(len(a) - 1 - i + k - 1, nums[len(a) - 1 - i + k - 1], parseInt10(a[i]), parseInt10(b[j]));
            }
            k = 0;
        }
        //core 2
        for (var n = 0; n < len(nums); n++) {
            if (nums[n] >= radix) {
                nums[n + 1] += parseInt10(nums[n] / radix);
                nums[n] %= radix;
            }

        }
        nums.reverse();
        nums = clearOpenZeroI(nums);
        var s = list2StrWithJoint(nums, '');
        if (eq(finalSign, '-')) {
            s = '-' + s;
        }
        return s;

    }

    function addInt10One(s) {
        // checkBigIntegerNumber10(s);
        return addInt10(s, '1');
    }

    function compareInt10(a, b) {
        checkBigIntegerNumber10(a);
        checkBigIntegerNumber10(b);
        if (len(a) > len(b)) {
            return 1;
        } else if (len(a) < len(b)) {
            return -1;
        }
        var i = 0;
        while (eq(a[i], b[i]) && i < len(a)) {
            i++;
        }
        if (eq(i, len(a))) {
            return 0;
        }
        else if (a[i] > b[i]) {
            return 1;
        } else if (a[i] < b[i]) {
            return -1;
        }
        return 0;
    }

    function gtInt10(a, b) {
        return compareInt10(a, b) > 0;
    }
    function ltInt10(a, b) {
        return compareInt10(a, b) < 0;
    }
    function eqInt10(a, b) {
        return eq(compareInt10(a, b), 0);
    }


    function powerInt10(s, p) {
        if (!int10RegExp.test(s)) {
            throw new Error("params must be decimal number and sign only one +/-!");
        }
        var finalSign = whatSign(s);
        s = getRidOfSign(s);
        checkBigIntegerNumber10(s);
        s = clearOpenZeroS(s);
        var num = '1';
        p = String(p);
        for (var i = '0'; ltInt10(i, p); i = addInt10One(i)) {
            num = multiplyInt10(num, s);
        }
        if (eq(finalSign, '-')) {
            num = '-' + num;
        }
        return num;
    }

    function substractInt10(a, b) {
        //check decimal format
        if (!(int10RegExp.test(a) && int10RegExp.test(b))) {
            throw new Error("params must be decimal number and sign only one +/-!");
        }
        //calc sign
        // var asign = whatSign(a);
        var bsign = whatSign(b);

        // a = getRidOfSign(a);
        b = getRidOfSign(b);

        //exchange sign '+' and '-'
        b = eq(bsign, '-') ? b : '-' + b;

        return addInt10(a, b);

    }

    function divideInt10(a, b) {
        //check decimal format
        if (!(int10RegExp.test(a) && int10RegExp.test(b))) {
            throw new Error("params must be decimal number and sign only one +/-!");
        }
        //calc sign
        var asign = whatSign(a);
        var bsign = whatSign(b);

        a = getRidOfSign(a);
        b = getRidOfSign(b);


        checkBigIntegerNumber10(a);
        checkBigIntegerNumber10(b);

        a = clearOpenZeroS(a);
        b = clearOpenZeroS(b);

        if (eq(b, '0')) {
            throw new Error("divisor cannot be zero or 0");
        }

        var finalSign = eq(asign, bsign) ? '+' : '-';

        if (eq(a, '0')) {
            return eq(finalSign, '-') ? '-0' : '0';
        }

        //core
        var radix = '10';
        var quotient = '0';
        while (!(ltInt10(a, b))) {
            var rest = String(len(a) - len(b));
            var rest10 = powerInt10(radix, rest);
            var qn = multiplyInt10(b, rest10);
            if (gtInt10(qn, a)) {
                rest = substractInt10(rest, '1');
                rest10 = powerInt10(radix, rest);
            }
            qn = multiplyInt10(b, rest10);
            a = substractInt10(a, qn);
            quotient = addInt10(quotient, rest10);
        }


        if (eq(finalSign, '-')) {
            quotient = '-' + quotient;
        }
        return quotient;

    }

    function modInt10(a, b) {
        //check decimal format
        if (!(int10RegExp.test(a) && int10RegExp.test(b))) {
            throw new Error("params must be decimal number and sign only one +/-!");
        }
        //calc sign
        var asign = whatSign(a);
        var bsign = whatSign(b);

        a = getRidOfSign(a);
        b = getRidOfSign(b);


        checkBigIntegerNumber10(a);
        checkBigIntegerNumber10(b);

        a = clearOpenZeroS(a);
        b = clearOpenZeroS(b);

        if (eq(b, '0')) {
            throw new Error("divisor cannot be zero or 0");
        }

        var finalSign = asign;

        if (eq(a, '0')) {
            return eq(finalSign, '-') ? '-0' : '0';
        }

        //core
        var radix = '10';
        // var quotient = '0';
        while (!(ltInt10(a, b))) {
            var rest = String(len(a) - len(b));
            var rest10 = powerInt10(radix, rest);
            var qn = multiplyInt10(b, rest10);
            if (gtInt10(qn, a)) {
                rest = substractInt10(rest, '1');
                rest10 = powerInt10(radix, rest);
            }
            qn = multiplyInt10(b, rest10);
            a = substractInt10(a, qn);
            // quotient = addInt10(quotient, rest10);
        }


        if (eq(finalSign, '-')) {
            a = '-' + a;
        }
        return a;

    }


    function BigInteger(s, radix = 10) {
        ntfs(this, BigInteger);
        var r = checkRadixAndNumber(s, radix);
        this.s = r[0];
        this.data = str2ListBySeparator(this.s, '');
        this.radix = r[1];
        this.sign = r[2];
    }

    var BigInteger_impl = {
        bigint10: function () {//new bigint obj
            return new BigInteger(this.int10Value());
        },
        unsignedInt10Value: function () {//string
            var data = EMPTY_VALUES.ARRAY;
            var s = '0';
            var radix = String(this.radix);
            for (var i = len(this.s) - 1; i >= 0; i--) {
                s = addInt10(s,
                    multiplyInt10(
                        String(digitsMap.get(this.s[i])),
                        powerInt10(radix, len(this.s) - i - 1)
                    )
                );//have to multiply n*radix^N
            }
            return s;
        },
        int10Value: function () {
            var sign = this.sign;
            if (eq(sign, '+')) {
                sign = '';
            }
            return sign + this.unsignedInt10Value()
        },
        add: function (a) {
            notInstanceof(a, BigInteger, "param must be BigInteger object!");
            var aData = a.int10Value();
            var oData = this.int10Value();
            return new BigInteger(addInt10(aData, oData));
        },
        multiply: function (a) {
            notInstanceof(a, BigInteger, "param must be BigInteger object!");
            var aData = a.int10Value();
            var oData = this.int10Value();
            return new BigInteger(multiplyInt10(aData, oData));
        },
        substract: function (a) {
            notInstanceof(a, BigInteger, "param must be BigInteger object!");
            var aData = a.int10Value();
            var oData = this.int10Value();
            return new BigInteger(substractInt10(aData, oData));
        },
        divide: function (a) {
            notInstanceof(a, BigInteger, "param must be BigInteger object!");
            var aData = a.int10Value();
            var oData = this.int10Value();
            return new BigInteger(divideInt10(oData, aData));
        },
        mod: function (a) {
            notInstanceof(a, BigInteger, "param must be BigInteger object!");
            var aData = a.int10Value();
            var oData = this.int10Value();
            return new BigInteger(modInt10(oData, aData));
        },
        power: function (n) {
            //One:
            // var sum = BigInteger.ONE;
            // n = String(n);
            // for (var i = '0'; ltInt10(i, n); i = addInt10One(i)) {
            //     sum = sum.multiply(this);
            // }
            // return sum;
            //Two:
            return new BigInteger(powerInt10(this.int10Value(), String(n)));
        },
        negate: function () {
            return new BigInteger(
                eq(this.sign, '-')
                    ?
                    '+' + this.unsignedInt10Value()
                    :
                    '-' + this.unsignedInt10Value());
        },
        addOne: function () {
            return this.add(BigInteger.ONE);
        },
        toString: function () {
            return this.s;
        }

    };

    impl(BigInteger, BigInteger_impl);

    var BigInteger_static_impl = {
        ZERO: new BigInteger('0'),
        ONE: new BigInteger('1'),
    };
    static_impl(BigInteger, BigInteger_static_impl);

BigInteger 类

a = new xy.BigInteger('123')
BigInteger {s: "123", data: Array(3), radix: 10, sign: "+"}
b  = new xy.BigInteger('-111')
BigInteger {s: "111", data: Array(3), radix: 10, sign: "-"}
a.divide(b).int10Value()

 

js实现超大数字的加减乘除
qq_41827547的博客
04-24 7156
网上没发现超大数字运算的js实现，标题有，但是并不是真正的超大数运算，而且有很多乘法加法都不精确的拿出来坑人。我自己实现了一版，性能还不错，支持数百万长度的精确数字运算，测试乘法10万长度在1分钟内完成，加法百万长度在一分钟内。除法和乘法互相验证没问题。 原理和我们手算差不多，只不过我把它分块了，不是逐位运算，而是逐块，性能也就提高了很多。 代码如下 // 不可使用负数 functi...
js封装加减乘除四则运算解决精度丢失的问题
lzfengquan的博客
04-20 1357
JS 数字丢失精度的原因: 计算机的二进制实现和位数限制有些数无法有限表示。 意义: 1位用来表示符号位 11位用来表示指数 52位表示尾数 大整数的精度丢失和浮点数本质上是一样的，尾数位最大是 52 位，因此 JS 中能精准表示的最大整数是 Math.pow(2, 53)，十进制即 :9007199254740992。 大于 9007199254740992 的可能会丢失精度 注意的是toFixed()坑 解决 <!DOCTYPE html> <html lang="en">.
十进制四则运算计算器
06-13
以二叉树表示算术表达式的基础上，设计一个十进制的四则运算的计算器。
js 大整数加法、乘法、除法
meimeilive的专栏
09-05 3016
有一定的编程经验的人都知道，当我们对数据操作的时候，若数据过大，计算机将这个大数从十进制的转为二进制的，是没有那个类型的放的了的，因此，我们经常将一个大数转化为字符串来操作。接下来我将演示大整数的加法、乘法、除法操作。 附：不考虑负数 1、大整数加法 思路：我们将两个数进行逆序转换，然后按位进行相加，将相加的结果进行与10相除，商为进位，余数为当前位要保留的数。 //大整数加法 func...
JS 大整数相加
最新发布
Aotman_的博客
06-23 302
在JavaScript中处理大整数相加时，由于JavaScript的Number类型是基于IEEE 754标准的双精度64位浮点格式，它只能安全地表示从-(2^53 - 1)到2^53 - 1（大约是-9007199254740991到9007199254740991）之间的整数。超出这个范围的整数在进行加法运算时可能会失去精度，导致不正确的结果。
javascript乘法和加法_js 大整数加法、乘法、除法
weixin_28920823的博客
02-06 947
有一定的编程经验的人都知道，当我们对数据操作的时候，若数据过大，计算机将这个大数从十进制的转为二进制的，是没有那个类型的放的了的，因此，我们经常将一个大数转化为字符串来操作。接下来我将演示大整数的加法、乘法、除法操作。附：不考虑负数1、大整数加法思路：我们将两个数进行逆序转换，然后按位进行相加，将相加的结果进行与10相除，商为进位，余数为当前位要保留的数。//大整数加法function big_a...
c 语言 十进制四则运算,朋友，你知道回文十进制数和数列的四则运算嘛？
weixin_39530647的博客
05-21 275
/* 为字符串类型添加返回逆序字符串的方法 */String.prototype.reverse = function(){returnthis.split( "").reverse().join( "");}/* 从11 开始搜索 */varnum = 11;while( true){if((num.toString() == num.toString().reverse()) &&am...
javascript 四则运算精度修正函数代码
10-29
在编写JavaScript代码进行数值计算时，经常会遇到四则运算中精度问题的困扰。这个问题尤其在涉及到浮点数运算时更为明显。浮点数在计算机中是以二进制形式存储的，由于某些小数无法精确用二进制表示，导致了运算结果...
JavaScript实现基于十进制的四舍五入实例
10-23
在编程中，四舍五入是一种常见的数学运算，用于将一个实数转换为最接近的整数。在JavaScript中，四舍五入的实现通常是通过Math对象提供的方法来完成的。然而，有时候开发者可能需要实现一个自定义的四舍五入函数，...
JavaScript十进制计算decimal.js.zip
07-18
decimal.js 实现了对任意精度的十进制进行计算的 JavaScript 库。 标签：decimal
【大数算法】（ 十进制整数四则运算） 十进制运算与二进制比较与思考
Wis_nokia的专栏
02-23 2850
序   这两天心血来潮， 想熟悉下Eclipse。 偶是写Python的， 一般都在Ubuntu上用VIM做编辑器， PDB做调试工具， 自带的python2.7解释器， git做版本控制。 用着挺爽， 也就没有搞啥IDE， 但是最近发现要做大项目或工程的话， IDE啥的还是很有必要的。   几乎把所有支持Py的IDE都尝试过了， eric用着特别扭（还是比较习惯VIM的便捷操作）,  要Py
Verilog实现的十进制加减乘除（初学者）
12-10
实现的简单的Verilog进行十进制加减乘除，适合初学者。
biginteger.js:一个任意大小的 javascript 整数库。 实现所有基本算术函数，包括加法、减法、乘法、除法、取模和求幂
06-14
大整数.js 它是什么？ biginteger.js 是一个实现任意大小整数的 javascript 库。 方法可用于： 添加 减法 乘法 分配 模数 取幂 模幂运算 随机数 素性检查 此外，还有许多其他方法可用于相等性测试、基数之间的转换、查找最大值和最小值等。 阅读以查看每种方法的文档。 例子 是一个小而有用的网络应用程序，它展示了 biginteger.js 的素性检查的强大功能。 参考 长除法和取模的算法改编自 Per Brinch Hansen 的 。 Jerry Shurman 从提取了一种有效的模幂算法。 执照 麻省理工学院执照。 有关完整条款，请参阅随附的许可文件。
大整数除法
u013129143的博客
11-11 1987
思路 1.不断做减法 7546 / 23 开始 商为0, 先减去23的一百倍,也就是2300,发现能减3次,余下645,于是商增加3*100然后用645-23的十倍,能减2次,余下186,商增加20,最后用186-23,能减8次,最后商为328 //减完 从后数起第一个不为0的数是num1的长度 //len1&lt;len2 //len1=len2 num1[len1]&lt;num2[len...
JS 位操作符
青蛙king的博客
11-12 370
目录 一、位运算的原理 二、认识位操作符 三、应用举例 1、按位非（~） 2、按位与（&） 3、按位或（|） 4、按位异或（^） 5、左移（<<） 6、有符号位的右移（>>） 7、无符号位的右移（>>>） 一、位运算的原理 将64位的数值转换成32数值，然后执行位操作，最后将32的结果转换回64位的数值。 拓展： ...
十进制四则运算计算器c语言,十进制四则运算计算器代码，输入为字符串(示例代码)...
weixin_39629467的博客
05-23 780
转发个严蔚敏老师的《数据结构及应用算法教程》里的十进制四则运算计算器代码，实习生笔试遇到过不会写，特此做个记录。**************************文件：calculator.c**************************#define NonEmpty 0#define PLUS -1// ‘+‘#define MINUS -2// ‘-‘#define A...
超大整数的加减乘除运算及X进制转换
wtogether的专栏
05-16 1194
Option ExplicitPublic Function IIf(ByVal blnExp, vtTrue, vtFalse)    If blnExp Then        IIf = vtTrue    Else        IIf = vtFalse    End IfEnd FunctionPublic Function ChangeType(vtData, vtType)   
使用javascript写一个进制的计算器
wumanxin2018的博客
09-23 1061
javascript开发实用的小工具
JavaScript实现带小数点的四则运算代码解析
代码示例中提到了通过对象的方式调用计算功能，这意味着可能会有一个类似于计算器的对象，它包含加、减、乘、除等方法，用户通过调用对象的这些方法来进行计算。 ```javascript let calculator = { add: function...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值