Question

我希望看到二进制中的整数，正数或负数。

与this question相似，但对于JavaScript。

Answer 1

<强>答案：

function dec2bin(dec){
    return (dec >>> 0).toString(2);
}

dec2bin(1);    // 1
dec2bin(-1);   // 11111111111111111111111111111111
dec2bin(256);  // 100000000
dec2bin(-256); // 11111111111111111111111100000000

您可以使用Number.toString(2)功能，但在表示负数时会出现问题。例如，(-1).toString(2)输出为"-1"。

要解决此问题，您可以使用无符号右移位运算符（>>>）将您的数字强制转换为无符号整数。

如果你运行(-1 >>> 0).toString(2)，你会将你的数字0位向右移动，这不会改变数字本身，但它将表示为无符号整数。上面的代码会正确输出"11111111111111111111111111111111"。

This question有进一步的解释。

-3 >>> 0（右逻辑移位）强制其无符号整数的参数，这就是为什么你得到-3的32位二进制补码表示。

注1 ：此答案需要Number作为参数，因此请相应地进行转换。

注意2 ：结果是字符串没有前导零，因此请根据需要应用填充。

Answer 2

尝试

num.toString(2);

2是基数，可以是2到36之间的任何基数

来源here

<强>更新

这仅适用于正数，Javascript表示二进制补码表示的负二进制整数。我做了这个小功能应该做的伎俩，我没有正确测试它：

function dec2Bin(dec)
{
    if(dec >= 0) {
        return dec.toString(2);
    }
    else {
        /* Here you could represent the number in 2s compliment but this is not what 
           JS uses as its not sure how many bits are in your number range. There are 
           some suggestions https://stackoverflow.com/questions/10936600/javascript-decimal-to-binary-64-bit 
        */
        return (~dec).toString(2);
    }
}

我从here

获得了一些帮助

Answer 3

二进制文件＆＃39;转换为二进制＆＃39;可以参考三件主要的事情。位置编号系统，内存中的二进制表示或32位位串。（对于64位位串，请参见Patrick Roberts' answer）

<强> 1。号码系统

(123456).toString(2)会将数字转换为基数2 positional numeral system。在这个系统中，负数用减号写成，就像十进制一样。

<强> 2。内部代表

数字的内部表示为64 bit floating point，this answer中讨论了一些限制。 没有简单的方法在javascript中创建此字符串表示形式，也无法访问特定位。

第3。面具＆amp;按位运算符

MDN对按位运算符的工作方式有good overview。重要的是：

按位运算符将其操作数视为 32位（零和1）的序列

在应用操作之前，64位浮点数被转换为32位有符号整数。他们被转换回来之后。

这是用于将数字转换为32位字符串的MDN示例代码。

function createBinaryString (nMask) {
  // nMask must be between -2147483648 and 2147483647
  for (var nFlag = 0, nShifted = nMask, sMask = ""; nFlag < 32;
       nFlag++, sMask += String(nShifted >>> 31), nShifted <<= 1);
  return sMask;
}

createBinaryString(0) //-> "00000000000000000000000000000000"
createBinaryString(123) //-> "00000000000000000000000001111011"
createBinaryString(-1) //-> "11111111111111111111111111111111"
createBinaryString(-1123456) //-> "11111111111011101101101110000000"
createBinaryString(0x7fffffff) //-> "01111111111111111111111111111111"

Answer 4

一个简单的方法就是......

Number(42).toString(2);

// "101010"

Answer 5

此答案尝试解决绝对值介于Number.MAX_SAFE_INTEGER（或2**53-1）和2**31之间的整数。当前解决方案仅解决32位内的有符号整数，但此解决方案将使用float64ToInt64Binary()以64位二进制补码形式输出：

// IIFE to scope internal variables
var float64ToInt64Binary = (function () {
  // create union
  var flt64 = new Float64Array(1)
  var uint16 = new Uint16Array(flt64.buffer)
  // 2**53-1
  var MAX_SAFE = 9007199254740991
  // 2**31
  var MAX_INT32 = 2147483648

  function uint16ToBinary() {
    var bin64 = ''

    // generate padded binary string a word at a time
    for (var word = 0; word < 4; word++) {
      bin64 = uint16[word].toString(2).padStart(16, 0) + bin64
    }

    return bin64
  }

  return function float64ToInt64Binary(number) {
    // NaN would pass through Math.abs(number) > MAX_SAFE
    if (!(Math.abs(number) <= MAX_SAFE)) {
      throw new RangeError('Absolute value must be less than 2**53')
    }

    var sign = number < 0 ? 1 : 0

    // shortcut using other answer for sufficiently small range
    if (Math.abs(number) <= MAX_INT32) {
      return (number >>> 0).toString(2).padStart(64, sign)
    }

    // little endian byte ordering
    flt64[0] = number

    // subtract bias from exponent bits
    var exponent = ((uint16[3] & 0x7FF0) >> 4) - 1022

    // encode implicit leading bit of mantissa
    uint16[3] |= 0x10
    // clear exponent and sign bit
    uint16[3] &= 0x1F

    // check sign bit
    if (sign === 1) {
      // apply two's complement
      uint16[0] ^= 0xFFFF
      uint16[1] ^= 0xFFFF
      uint16[2] ^= 0xFFFF
      uint16[3] ^= 0xFFFF
      // propagate carry bit
      for (var word = 0; word < 3 && uint16[word] === 0xFFFF; word++) {
        // apply integer overflow
        uint16[word] = 0
      }

      // complete increment
      uint16[word]++
    }

    // only keep integer part of mantissa
    var bin64 = uint16ToBinary().substr(11, Math.max(exponent, 0))
    // sign-extend binary string
    return bin64.padStart(64, sign)
  }
})()

console.log('8')
console.log(float64ToInt64Binary(8))
console.log('-8')
console.log(float64ToInt64Binary(-8))
console.log('2**33-1')
console.log(float64ToInt64Binary(2**33-1))
console.log('-(2**33-1)')
console.log(float64ToInt64Binary(-(2**33-1)))
console.log('2**53-1')
console.log(float64ToInt64Binary(2**53-1))
console.log('-(2**53-1)')
console.log(float64ToInt64Binary(-(2**53-1)))
console.log('2**52')
console.log(float64ToInt64Binary(2**52))
console.log('-(2**52)')
console.log(float64ToInt64Binary(-(2**52)))
console.log('2**52+1')
console.log(float64ToInt64Binary(2**52+1))
console.log('-(2**52+1)')
console.log(float64ToInt64Binary(-(2**52+1)))

.as-console-wrapper {
  max-height: 100% !important;
}

这个答案主要涉及IEEE-754 Double-precision floating-point format，如图所示：

   seee eeee eeee ffff ffff ffff ffff ffff ffff ffff ffff ffff ffff ffff ffff ffff
   ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
   [    uint16[3]    ] [    uint16[2]    ] [    uint16[1]    ] [    uint16[0]    ]
   [                                   flt64[0]                                  ]

   little endian byte ordering

   s = sign = uint16[3] >> 15
   e = exponent = (uint16[3] & 0x7FF) >> 4
   f = fraction

解决方案的工作方式是在小端字节排序中创建64位浮点数和无符号16位整数数组之间的并集。验证整数输入范围后，它将输入转换为缓冲区上的双精度浮点数，然后使用并集获取对该值的位访问权限，并根据无偏二进制指数和分数位计算二进制字符串。 / p>

该解决方案在纯ECMAScript 5中实现，但使用String#padStart()的an available polyfill here除外。

Answer 6

注意 - 当x为正时，基本(x>>>0).toString(2);有一个小问题。我在答案结尾处有一些示例代码，用＆gt;＆gt;＆gt;来纠正这个问题仍在使用＆gt;＆gt;＆gt;。

的方法

(-3>>>0).toString(2);

prints -3 in 2s complement.

1111111111101

一个工作示例

C:\>type n1.js
console.log(   (-3 >>> 0).toString(2)    );
C:\>
C:\>node n1.js
11111111111111111111111111111101

C:\>

这在URL栏中是另一个快速证明

javascript:alert((-3>>>0).toString(2))

注意 - 结果有轻微缺陷，因为它始终以1开头，对于负数很好。对于正数，你应该在开头前加一个0，这样结果就是2s补码。因此，(8>>>0).toString(2)产生1000，其中2个补码中不是8个，但是在0之前，使其为01000，是正确的8 in 2s补码。在适当的2s补码中，以0开始的任何位串都是> = 0，并且以1开始的任何位串都是负的。

e.g。这就解决了这个问题

// or x=-5  whatever number you want to view in binary  
x=5;   
if(x>0) prepend="0"; else prepend=""; 
alert(prepend+((x>>>0)).toString(2));

其他解决方案是来自安南的解决方案（尽管安南的解释和定义充满了错误，他的代码可以产生正确的输出），以及Patrick的解决方案。

任何不了解从0开始的正数和在2s补码中以1为负数的事实的人都可以在2s补码上检查这个SO QnA。 What is “2's Complement”?

Answer 7

您可以编写自己的函数来返回位数组。示例如何将数字转换为位

除数|股息|比特/余数

2 | 9 | 1

2 | 4 | 0

2 | 2 | 0

〜| 1 |〜

上述行的示例：2 * 4 = 8，余数为1 所以9 = 1 0 0 1

function numToBit(num){
    var number = num
    var result = []
    while(number >= 1 ){
        result.unshift(Math.floor(number%2))
        number = number/2
    }
    return result
}

从下到上阅读余数。数字1在中间到顶部。

Answer 8

这是我设法处理的方式：

const decbin = nbr => {
  if(nbr < 0){
     nbr = 0xFFFFFFFF + nbr + 1
  }
  return parseInt(nbr, 10).toString(2)
};

通过以下链接获取了它：https://locutus.io/php/math/decbin/

Answer 9

我们还可以如下计算正数或负数的二进制数：

function toBinary(n){
    let binary = "";
    if (n < 0) {
      n = n >>> 0;
    }
    while(Math.ceil(n/2) > 0){
        binary = n%2 + binary;
        n = Math.floor(n/2);
    }
    return binary;
}

console.log(toBinary(7));
console.log(toBinary(-7));

Answer 10

我使用了一种不同的方法来完成此任务。我决定不在我的项目中使用此代码，但我认为我会将其保留在适当的位置，以防对某人有用。

不使用移位或二进制补码强制。
您选择出现的位数（它会检查有效值'8'，'16'，'32'，但我想您可以更改该值）
您选择将其视为有符号整数还是无符号整数。
尽管您想改善错误处理，但是它会检查有符号/无符号和位数的组合是否存在范围问题。
它也具有函数的“反向”版本，该功能将位转换回int。您将需要它，因为可能没有其他东西可以解释此输出了：D

function intToBitString(input, size, unsigned) {
	if ([8, 16, 32].indexOf(size) == -1) {
		throw "invalid params";
	}
	var min = unsigned ? 0 : - (2 ** size / 2);
        var limit = unsigned ? 2 ** size : 2 ** size / 2;
	if (!Number.isInteger(input) || input < min || input >= limit) {
		throw "out of range or not an int";
	}
	if (!unsigned) {
		input += limit;
	}
	var binary = input.toString(2).replace(/^-/, '');
	return binary.padStart(size, '0');
}

function bitStringToInt(input, size, unsigned) {
	if ([8, 16, 32].indexOf(size) == -1) {
		throw "invalid params";
	}
	input = parseInt(input, 2);
	if (!unsigned) {
		input -= 2 ** size / 2;
	}
	return input;
}


// EXAMPLES

var res;
console.log("(uint8)10");
res = intToBitString(10, 8, true);
console.log("intToBitString(res, 8, true)");
console.log(res);
console.log("reverse:", bitStringToInt(res, 8, true));
console.log("---");

console.log("(uint8)127");
res = intToBitString(127, 8, true);
console.log("intToBitString(res, 8, true)");
console.log(res);
console.log("reverse:", bitStringToInt(res, 8, true));
console.log("---");

console.log("(int8)127");
res = intToBitString(127, 8, false);
console.log("intToBitString(res, 8, false)");
console.log(res);
console.log("reverse:", bitStringToInt(res, 8, false));
console.log("---");

console.log("(int8)-128");
res = intToBitString(-128, 8, false);
console.log("intToBitString(res, 8, true)");
console.log(res);
console.log("reverse:", bitStringToInt(res, 8, true));
console.log("---");

console.log("(uint16)5000");
res = intToBitString(5000, 16, true);
console.log("intToBitString(res, 16, true)");
console.log(res);
console.log("reverse:", bitStringToInt(res, 16, true));
console.log("---");

console.log("(uint32)5000");
res = intToBitString(5000, 32, true);
console.log("intToBitString(res, 32, true)");
console.log(res);
console.log("reverse:", bitStringToInt(res, 32, true));
console.log("---");

Answer 11

您可以使用递归解决方案：

import sys

sys.argv[0]
file_path = sys.argv[1]
text_name = sys.argv[2]

if len(sys.argv)<2:
    print ("Fatal: You forgot to include the directory name on the command line.")
    print( "Usage:  python %s <directoryname>" % sys.argv[0])
    sys.exit(0)

with open(file_path, 'rb') as pdf_file:
    pdf_reader = PdfFileReader(pdf_file)

num_pages = pdf_reader.numPages
with open(text_name, 'w') as txt_file:
    for p in range(num_pages):
        page = pdf_reader.getPage(p)
        lines = page.extractText().replace('\n', '').replace('"', '').split('.')


    for line in lines:
        if any(char.isalnum for char in line):
         txt_file.write(line.strip() + '.\n')```

仅适用于正数。

Answer 12

另一种选择

const decToBin = dec => {
  let bin = '';
  let f = false;

  while (!f) {
    bin = bin + (dec % 2);    
    dec = Math.trunc(dec / 2);  

    if (dec === 0 ) f = true;
  }

  return bin.split("").reverse().join("");
}

console.log(decToBin(0));
console.log(decToBin(1));
console.log(decToBin(2));
console.log(decToBin(3));
console.log(decToBin(4));
console.log(decToBin(5));
console.log(decToBin(6));

Answer 13

这是我的代码：

var x = prompt("enter number", "7");
var i = 0;
var binaryvar = " ";

function add(n) {
    if (n == 0) {
        binaryvar = "0" + binaryvar; 
    }
    else {
        binaryvar = "1" + binaryvar;
    }
}

function binary() {
    while (i < 1) {
        if (x == 1) {
            add(1);
            document.write(binaryvar);
            break;
        }
        else {
            if (x % 2 == 0) {
                x = x / 2;
                add(0);
            }
            else {
                x = (x - 1) / 2;
                add(1);
            }
        }
    }
}

binary();

Answer 14

这是解决方案。事实上它非常简单

<android.support.design.widget.TabLayout
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:id="@+id/tabLayout"/>

如何在JavaScript中将整数转换为二进制？

14 个答案:

除数|股息|比特/余数

2 | 9 | 1

2 | 4 | 0

2 | 2 | 0

〜| 1 |〜