一个简单的方法就是……

Number(42).toString(2);

// "101010"

逻辑可以被任何编程语言实现的实际解决方案:

如果你确定它只是积极的:

var a = 0;
var n = 12; // your input
var m = 1;
while(n) {
    a = a + n%2*m;
    n = Math.floor(n/2);
    m = m*10;
}

console.log(n, ':', a) // 12 : 1100

若能负或正——

(n >>> 0).toString(2)

我用了一种不同的方法来解决这个问题。我决定在我的项目中不使用这段代码，但我想我会把它放在相关的地方，以防它对某人有用。

Doesn't use bit-shifting or two's complement coercion. You choose the number of bits that comes out (it checks for valid values of '8', '16', '32', but I suppose you could change that) You choose whether to treat it as a signed or unsigned integer. It will check for range issues given the combination of signed/unsigned and number of bits, though you'll want to improve the error handling. It also has the "reverse" version of the function which converts the bits back to the int. You'll need that since there's probably nothing else that will interpret this output :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("---");

“convert to binary”中的二进制可以指三个主要的东西。位置数系统，内存中的二进制表示或32位位串。(64位位串参见Patrick Roberts的回答)

1. 数字系统

(123456). tostring(2)将数字转换为以2为基数的位置数字系统。在这个系统中，负数被写成负号，就像在十进制中一样。

2. 内部表示

数字的内部表示是64位浮点数，在这个答案中讨论了一些限制。没有简单的方法在javascript中创建一个比特字符串表示，也不能访问特定的位。

3.掩码和位操作符

MDN很好地概述了位操作符的工作方式。重要的是:

位操作符将其操作数视为32位序列(0和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"

这个答案试图用214748364810(231)- 900719925474099110(253-1)范围内的绝对值来处理输入。

在JavaScript中，数字以64位浮点表示形式存储，但位操作将它们强制转换为二进制补码格式的32位整数，因此任何使用位操作的方法都将输出范围限制为-214748364810(-231)- 214748364710(231-1)。

然而，如果避免按位操作，并且只使用数学运算来保留64位浮点表示法，则可以通过符号扩展53位的twosComplement，将任何安全整数可靠地转换为64位的二进制补码表示法:

function toBinary (value) { if (!Number.isSafeInteger(value)) { throw new TypeError('value must be a safe integer'); } const negative = value < 0; const twosComplement = negative ? Number.MAX_SAFE_INTEGER + value + 1 : value; const signExtend = negative ? '1' : '0'; return twosComplement.toString(2).padStart(53, '0').padStart(64, signExtend); } function format (value) { console.log(value.toString().padStart(64)); console.log(value.toString(2).padStart(64)); console.log(toBinary(value)); } format(8); format(-8); format(2**33-1); format(-(2**33-1)); format(2**53-1); format(-(2**53-1)); format(2**52); format(-(2**52)); format(2**52+1); format(-(2**52+1)); .as-console-wrapper{max-height:100%!important}

对于较旧的浏览器，存在以下函数和值的填充:

Number.isSafeInteger () Number.isInteger () 号码。MAX_SAFE_INTEGER String.prototype.padStart ()

作为额外的奖励，如果您使用BigInt对⌈64 / log2(基数)⌉数字中的负数执行两个补数转换，您可以支持任何基数(2-36):

function toRadix (value, radix) { if (!Number.isSafeInteger(value)) { throw new TypeError('value must be a safe integer'); } const digits = Math.ceil(64 / Math.log2(radix)); const twosComplement = value < 0 ? BigInt(radix) ** BigInt(digits) + BigInt(value) : value; return twosComplement.toString(radix).padStart(digits, '0'); } console.log(toRadix(0xcba9876543210, 2)); console.log(toRadix(-0xcba9876543210, 2)); console.log(toRadix(0xcba9876543210, 16)); console.log(toRadix(-0xcba9876543210, 16)); console.log(toRadix(0x1032547698bac, 2)); console.log(toRadix(-0x1032547698bac, 2)); console.log(toRadix(0x1032547698bac, 16)); console.log(toRadix(-0x1032547698bac, 16)); .as-console-wrapper{max-height:100%!important}

如果你对我的旧答案感兴趣，使用ArrayBuffer来创建一个Float64Array和Uint16Array之间的联盟，请参考这个答案的修订历史。

我希望看到二进制形式的正整数或负整数。

这是一个老问题，我认为这里有很好的解决方案，但没有解释这些聪明的解决方案的使用。

首先，我们需要理解一个数字可以是正数也可以是负数。 此外，JavaScript提供了一个MAX_SAFE_INTEGER常量，其值为9007199254740991。这个数字背后的原因是JavaScript使用IEEE 754中指定的双精度浮点格式数字，并且只能安全地表示-(2^53 - 1)和2^53 - 1之间的整数。

所以，现在我们知道了数字“安全”的范围。此外，JavaScript ES6有内置方法number . issafeinteger()来检查一个数字是否是一个安全的整数。

逻辑上，如果我们想用二进制表示一个数字n，这个数字需要53位，但是为了更好的表示，让我们使用7组8位= 56位，并使用padStart函数根据其符号将左侧填充为0或1。

接下来，我们需要处理正数和负数:正数左边加0，负数左边加1。同样，负数将需要一个二补表示。我们可以很容易地通过添加Number来解决这个问题。MAX_SAFE_INTEGER + 1的数字。

例如，我们想将-3表示为二进制，让我们假设Number。MAX_SAFE_INTEGER = 00000000 11111111 (255) then Number。MAX_SAFE_INTEGER + 1将是00000001 00000000(256)。现在让我们加上数字number。MAX_SAFE_INTEGER + 1 -3，这将是00000000 11111101(253)，但正如我们所说，我们将在左侧填充1，如11111111 11111101(-3)，这在二进制中表示-3。

另一种算法是我们在数字上加1然后像这样求符号的倒数-(-3 + 1)= 2这将是00000000 00000010(2)现在我们像这样求每一位11111111 11111101(-3)我们又得到了-3的二进制表示。

下面是这些算法的工作代码片段:

function dec2binA(n) { if (!Number.isSafeInteger(n)) throw new TypeError('n value must be a safe integer') if (n > 2**31) throw 'number too large. number should not be greater than 2**31' if (n < -1*(2**31)) throw 'number too far negative, number should not be lesser than 2**31' const bin = n < 0 ? Number.MAX_SAFE_INTEGER + 1 + n : n const signBit = n < 0 ? '1' : '0' return parseInt(bin, 10).toString(2) .padStart(56, signBit) .replace(/\B(?=(.{8})+(?!.))/g, ' ') } function dec2binB(n) { if (!Number.isSafeInteger(n)) throw new TypeError('n value must be a safe integer') if (n > 2**31) throw 'number too large. number should not be greater than 2**31' if (n < -1*(2**31)) throw 'number too far negative, number should not be lesser than 2**31' const bin = n < 0 ? -(1 + n) : n const signBit = n < 0 ? '1' : '0' return parseInt(bin, 10).toString(2) .replace(/[01]/g, d => +!+d) .padStart(56, signBit) .replace(/\B(?=(.{8})+(?!.))/g, ' ') } const a = -805306368 console.log(a) console.log('dec2binA:', dec2binA(a)) console.log('dec2binB:', dec2binB(a)) const b = -3 console.log(b) console.log('dec2binA:', dec2binA(b)) console.log('dec2binB:', dec2binB(b))