Javascript：添加两个二进制数（返回二进制）

我有两个二进制输入，我也返回二进制的加法结果

var addBinary = function(a, b) {
    var dec = Number(parseInt(a, 2)) + Number(parseInt(b, 2));
    return dec.toString(2);
};

对于一些疯狂的大二进制，比如

a=101000010010011001100100000010101111011001101110111111110100000101111111111111110000101111110001111110001111100101

b=11010100101111100011111110011000101010000111011101011010000011011001011101111100000011011011011011011011011011011011011011011011011011011011011011011011011011011011001

我正在输出

1101111011000100110001011101101000000011101000101011000000000000000000000000000000000000000000000000

假设正确的输出在哪里

1101111011000100110001011101101000000011101000101011001000010110110000100001100110011110010011000000000

---

是因为溢流吗？如果是这样，Javascript对二进制加法溢出有哪些限制？对不起，1和0太多了。

在我看来，这是因为这些NUM太大，无法失去精度

var addBinary = function(a, b) {
    var dec = Number(parseInt(a, 2)) + Number(parseInt(b, 2));
    console.log("the number a is " + parseInt(a, 2));
    console.log("the number b is " + parseInt(b, 2));
    console.log("the dec is  " + dec);
    return dec.toString(2);
};
var a = "10100000100100110110010000010101111011011001101110111111111101000000101111001110001111100001101"
var b = "110101001011101110001111100110001010100001101011101010000011011011001011101111001100000011011110011"
console.log(addBinary(a, b));

结果是

the number a is 2.484789315402498e+28
the number b is 5.2670055459872975e+29
the dec is  5.515484477527547e+29
110111101100010011000101110110100000011101000101011000000000000000000000000000000000000000000000000

您可以看到numa和NUMBE都会丢失精度。如果将最后一个结果转换为二进制：

 parseInt("110111101100010011000101110110100000011101000101011000000000000000000000000000000000000000000000000", 2)

然后你会得到：

 5.515484477527547e+29. 

所以“toString（2）”的过程是正确的

我们手动模拟二进制进程来解决这个问题（假设输入字符串是正确的，因此我的代码中没有捕获任何异常。运行时环境是nodejs v4.6.0）：

并得到正确的输出

110111101100010011000101110110100000011101000101011001000011011000001100011110011010010011000000000

---

我已经开发了一个用Javascript进行二进制加法的解决方案

我最初的目标是通过在Javascript中复制数字二进制加法器电路中使用的机制来巩固我对二进制逻辑的理解（不使用基转换或位运算符）

您可以在上找到我的原始项目的工作版本

它在DOM中所做的比您可能需要的多得多，但是当我插入您的数字（下面提到的调整）时，我很高兴看到它工作了

---

忘掉Javascript的操作精度，想想如何在数学中加上一个二进制

例如，

11

+

10

首先，我们应该从右到左开始。 现在我们得到

1 + 0 = 1

之后，我们进入下一步。

1 + 1 = 10

如果我们使用Javascript，如何得到结果

我们知道，

Mod

可以得到剩余的号码，

Division

可以得到进位。 在十进制中，我们得到

1+1=2

，如何将

2

转换为

10

。 我们可以使用

result % 2   // we can get single digit
result / 2 | 0   // we can get tens digit, `| 0` can remove decimal.

现在我们可以把这两条线连在一起

BinaryNumber = result / 2 | 0 + result % 2 + ''  // string concat

因此，我们的最终代码可以是：

/**
 * @param {string} a
 * @param {string} b
 * @return {string}
 */
var addBinary = function(a, b) {
    var i = a.length - 1;
    var j = b.length - 1;
    var carry = 0;
    var result = "";
    while(i >= 0 || j >= 0) {
        var m = i < 0 ? 0 : a[i] | 0;
        var n = j < 0 ? 0 : b[j] | 0;
        carry += m + n; // sum of two digits
        result = carry % 2 + result; // string concat
        carry = carry / 2 | 0; // remove decimals,  1 / 2 = 0.5, only get 0
        i--;
        j--;
    }
    if(carry !== 0) {
        result = carry + result;
    }
    return result;
};

/**
*@param{string}a
*@param{string}b
*@return{string}
*/
var addBinary=函数（a，b）{
var i=a.长度-1；
var j=b.长度-1；
var进位=0；
var结果=”；
而（i>=0 | | j>=0）{
var m=i<0？0:a[i]| 0；
var n=j<0？0:b[j]| 0；
进位+=m+n；//两位数之和
结果=进位%2+结果；//字符串concat
进位=进位/2 | 0；//去掉小数，1/2=0.5，只得到0
我--；
j--；
}
如果（进位！==0）{
结果=进位+结果；
}
返回结果；
};

这里有一个简单的解决方案，假设

a

和

b

是两个二进制字符串，那么返回它们的

和也为二进制字符串

let addBinary = (a, b) => {
  // handle corner cases when either input is empty
  if (a === null || a.length === 0) return b;
  if (b === null || b.length === 0) return a;

  let i = a.length - 1;
  let j = b.length - 1;
  let carry = 0;
  let sum = '';

  while (i >=0 || j >= 0) {
    let x = i < 0 ? 0 : +a[i];
    let y = j < 0 ? 0 : +b[i];
    let val = x + y + carry;

    carry = val > 1 ? 1 : 0;
    sum = val % 2 + sum;

    i--;
    j--;
  }

  return carry > 0 ? carry + sum : sum;
};

让addBinary=（a，b）=>{
//当任一输入为空时，处理转角情况
如果（a==null | | a.length==0）返回b；
如果（b==null | | b.length==0）返回a；
设i=a.长度-1；
设j=b.长度-1；
让进位=0；
让sum=''；
而（i>=0 | | j>=0）{
设x=i<0？0:+a[i]；
设y=j<0？0:+b[i]；
设val=x+y+进位；
进位=val>1？1:0；
sum=val%2+sum；
我--；
j--；
}
返回进位>0？进位+和：和；
};

关于二进制加法的一些基本规则：


0+0=0
0+1=1
1+0=1
1+1=0，进位=1

希望这能有所帮助
 添加2个n长度二进制整数的简单而简单的解决方案：

function binaryAddition(num1, num2) {
  let result = [];
  let carry = 0;
  for(let i = num1.length-1; i >= 0; i--) {
    if((num1[i] === 1 && num2[i] === 1)) {
      if(carry) {
       result.unshift(1) 
      } else {
       result.unshift(0);  
      }
      carry = 1;
    } else if((num1[i] === 0 && num2[i] === 0)) {
      if(carry) {
       result.unshift(1) 
      } else {
       result.unshift(0);  
      } 
      carry = 0;
    } else if((num1[i] === 1 && num2[i] === 0) || (num1[i] === 0 && num2[i] === 1)) {
      if(carry) {
       result.unshift(0)
       carry = 1;
      } else {
       result.unshift(1);  
      }
    }  
  }
  if(carry) result.unshift(1);
  return result;
}

支持不同长度的二进制字符串的通用解决方案
我在nice中添加了一个
padZeroes（）
函数，以创建一个支持不同长度二进制字符串的通用解决方案我的观点如下：
逻辑很简单，就像小学教的那样，从最右边的数字开始：我把第一个数字的最后一个数字和第二个数字的最后一个数字相加，并为下一轮保留进位

在每一轮（在
中，而在
中）我右键修剪两个数字，例如：

// number
1101 -> 110
// The math is simple: 1101/10|0 (divide by 10 and convert to integer)

输入和输出是字符串，以克服字符串长度可能更大的限制

完整代码：

函数二进制加法（a，b）{
var结果=”，
进位=0；
while（a | | b | | carry）{
让sum=+a.slice（-1）++b.slice（-1）+进位；//从每个数字和sum中获取最后一位数字
如果（总和>1）{
结果=总和%2+结果；
进位=1；
}
否则{
结果=总和+结果；
进位=0；
}
//修剪最后一位数字（110->11）
a=a.slice（0，-1）
b=b.slice（0，-1）
}
返回结果；
}
//测验
[
["0","0"],
["1","1"],
["1","0"],
["0","1"],
["10","1"],
["11","1"],
["10","10"],
["111","111"],
["1010","11"]
].forEach（数字=>
document.write(
数字[0]+“+”+
数字[1]+“=”+
二进制加法（数字[0]，数字[1]）+
"       (" +
parseInt（数字[0]，2）+“+”+
parseInt（数字[1]，2）+“=”+
parseInt（二进制加法（数字[0]，数字[1]），2）+
“”
”
)
)
document.body.style=“font:16px monospace”这是我的尝试。。。没有什么奇怪的简单逻辑

var addBinary = function(a, b) {
  let aLast = a.length - 1;
  let bLast = b.length - 1;

  let carry = 0;
  let aStr = [];

  while(aLast>=0 || bLast>=0){
    let sum = carry;
    if(aLast >= 0) {
      sum+= Number(a[aLast]);
      aLast--;
    }

    if(bLast >= 0) {
      sum+= Number(b[bLast]);
      bLast--
    }
    aStr.push(sum%2);
    carry = Math.floor(sum/2);
  }

  if(carry)     aStr.push(carry);

  return aStr.reverse().join("");
};

我还想添加我的解决方案


a='1111'；
设b='1111'；
让addBinary=（a，b）=>{
让最高的数字；
让最小数；
让答案=''；
让进位=0；
设aArr=a.split（“”）；
设bArr=b.split（“”）；
如果（平均长度>平均长度）
result % 2   // we can get single digit
result / 2 | 0   // we can get tens digit, `| 0` can remove decimal.

BinaryNumber = result / 2 | 0 + result % 2 + ''  // string concat

/**
 * @param {string} a
 * @param {string} b
 * @return {string}
 */
var addBinary = function(a, b) {
    var i = a.length - 1;
    var j = b.length - 1;
    var carry = 0;
    var result = "";
    while(i >= 0 || j >= 0) {
        var m = i < 0 ? 0 : a[i] | 0;
        var n = j < 0 ? 0 : b[j] | 0;
        carry += m + n; // sum of two digits
        result = carry % 2 + result; // string concat
        carry = carry / 2 | 0; // remove decimals,  1 / 2 = 0.5, only get 0
        i--;
        j--;
    }
    if(carry !== 0) {
        result = carry + result;
    }
    return result;
};

let addBinary = (a, b) => {
  // handle corner cases when either input is empty
  if (a === null || a.length === 0) return b;
  if (b === null || b.length === 0) return a;

  let i = a.length - 1;
  let j = b.length - 1;
  let carry = 0;
  let sum = '';

  while (i >=0 || j >= 0) {
    let x = i < 0 ? 0 : +a[i];
    let y = j < 0 ? 0 : +b[i];
    let val = x + y + carry;

    carry = val > 1 ? 1 : 0;
    sum = val % 2 + sum;

    i--;
    j--;
  }

  return carry > 0 ? carry + sum : sum;
};

function binaryAddition(num1, num2) {
  let result = [];
  let carry = 0;
  for(let i = num1.length-1; i >= 0; i--) {
    if((num1[i] === 1 && num2[i] === 1)) {
      if(carry) {
       result.unshift(1) 
      } else {
       result.unshift(0);  
      }
      carry = 1;
    } else if((num1[i] === 0 && num2[i] === 0)) {
      if(carry) {
       result.unshift(1) 
      } else {
       result.unshift(0);  
      } 
      carry = 0;
    } else if((num1[i] === 1 && num2[i] === 0) || (num1[i] === 0 && num2[i] === 1)) {
      if(carry) {
       result.unshift(0)
       carry = 1;
      } else {
       result.unshift(1);  
      }
    }  
  }
  if(carry) result.unshift(1);
  return result;
}

// number
1101 -> 110
// The math is simple: 1101/10|0 (divide by 10 and convert to integer)

var addBinary = function(a, b) {
  let aLast = a.length - 1;
  let bLast = b.length - 1;

  let carry = 0;
  let aStr = [];

  while(aLast>=0 || bLast>=0){
    let sum = carry;
    if(aLast >= 0) {
      sum+= Number(a[aLast]);
      aLast--;
    }

    if(bLast >= 0) {
      sum+= Number(b[bLast]);
      bLast--
    }
    aStr.push(sum%2);
    carry = Math.floor(sum/2);
  }

  if(carry)     aStr.push(carry);

  return aStr.reverse().join("");
};

function addBinary(a, b) {
  let result = "";
  let i = a.length - 1;
  let j = b.length - 1;
  let carry = 0;

  while (i >= 0 || j >= 0 || carry > 0) {
    const x = parseInt(a[i], 10) || 0;
    const y = parseInt(b[j], 10) || 0;
    const z = x + y + carry;
    i--, j--;

    // error handling: non-binary number
    if (z > 3 || z < 0) return console.error("non-binary number");

    result = z === 3 || z === 1 ? 1 + result : 0 + result;
    carry = z < 2 ? 0 : 1;
  }

  return result;
}

switch (z) {
   case 3:
      result = 1 + result;
      carry = 1;
      continue;
   case 2:
      result = 0 + result;
      carry = 1;
      continue;
   case 1:
      result = 1 + result;
      carry = 0;
      continue;
   case 0:
      result = 0 + result;
      carry = 0;
      continue;
   default:
      return console.error("non-binary number");
}

let addBinary = (a,b)=> parseInt(a,2)*parseInt(b,2).toString(2);