Как преобразовать целое число в двоичный код в JavaScript?

Я хотел бы видеть целые числа, положительные или отрицательные, в двоичном формате.

, а как этот вопрос, но для JavaScript.

9 ответов


этот ответ пытается адресовать целые числа с абсолютными значениями между Number.MAX_SAFE_INTEGER (или 2**53-1) и 2**31. Текущие решения адресуют только целые числа со знаком в пределах 32 бит, но это решение будет выводить в 64-разрядной форме дополнения два, используя float64ToInt64Binary():

// 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) - 1023

    // 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)))
.as-console-wrapper {
  max-height: 100% !important;
}

этот ответ в значительной степени касается IEEE-754 двойной точности с плавающей запятой формат, иллюстрированный здесь:

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-разрядным целочисленным массивом без знака в небольшом порядке байтов. После проверки целочисленного входного диапазона он преобразует входные данные в число с плавающей запятой двойной точности в буфере, а затем использует объединение для получения битового доступа к значению и вычисления двоичной строки на основе беспристрастного двоичного показателя и дроби биты.

решение реализовано в чистом ECMAScript 5, за исключением использования String#padStart(), имеющего доступный polyfill здесь.


ответ:

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" правильно.

этот вопрос Далее Объяснение.

-3 >>> 0 (правый логический сдвиг) связывает свои аргументы с целыми числами без знака, поэтому вы получаете 32-разрядное представление дополнения -3.


Примечание 1: этот ответ ожидает число в качестве аргумента, поэтому преобразуйте его соответственно.

примечание 2.: результат-строку без ведущие нули, поэтому применяйте прокладку по мере необходимости.


попробовать

num.toString(2);

2-это радикс и может быть любой базой между 2 и 36

источник здесь

обновление:

это будет работать только для положительных чисел, 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);
    }
}

у меня была помощь от здесь


двоичный файл в 'convert to binary' может относиться к трем основным вещам. Позиционная система счисления, двоичное представление в памяти или 32-битные битовые строки. (для 64бит bitstrings см. ответ Патрика Робертса)

1. Система Счисления

(123456).toString(2) преобразует числа в базу 2 позиционная система счисления. В этой системе отрицательные числа записываются со знаками минус, как и в десятичной системе.

2. Внутреннее Представление

внутреннее представление чисел 64 бит с плавающей запятой и некоторые ограничения описаны в ответ. Есть не просто чтобы создать бит-строковое представление этого в javascript или получить доступ к определенным битам.

3. Маски И Побитовые Операторы

MDN имеет хороший обзор о том, как работают побитовые операторы. Главное:

побитовые операторы трактуют свои операнды как последовательность 32 бит (нулей и единиц)

перед применением операций 64-разрядные числа с плавающей запятой преобразуются в 32-разрядные целые числа со знаком. После того, как они обратятся обратно.

вот пример кода MDN для преобразования чисел в 32-разрядные строки.

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"

самый простой способ-это просто...

Number(42).toString(2);

// "101010"

Примечание - основные (x>>>0).toString(2); имеет небольшую проблему, когда x положительный. У меня есть пример кода в конце моего ответа, который исправляет эту проблему с помощью метода>>>, все еще используя >>>.

(-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, которое на самом деле не 8 в дополнении 2s, но добавляя, что 0, что делает его 01000, является правильным 8 в дополнении 2s. В правильном дополнении 2s любая битовая строка, начинающаяся с 0, равна >=0, а любая битовая строка, начинающаяся с 1, отрицательна.

например, это обходит эту проблему

// 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));

другие решения-это решение Аннана (хотя объяснения и определения Аннана полны ошибок, он имеет код, который производит правильный вывод), и решение от Патрика.

любой, кто не понимает факт положительных чисел, начинающихся с 0 и отрицательных чисел с 1, в дополнении 2s, может проверить это так QnA на дополнении 2s. что такое "дополнение 2"?


вы можете написать собственную функцию, которая возвращает массив битов. Пример преобразования числа в бит

делитель / дивиденд/биты / остаток

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 в середине сверху.


Это мой код:

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();

Это решение . Это довольно просто на самом деле

function binaries(num1){ 
        var str = num1.toString(2)
        return(console.log('The binary form of ' + num1 + ' is: ' + str))
     }
     binaries(3

)

        /*
         According to MDN, Number.prototype.toString() overrides 
         Object.prototype.toString() with the useful distinction that you can 
         pass in a single integer argument. This argument is an optional radix, 
         numbers 2 to 36 allowed.So in the example above, we’re passing in 2 to 
         get a string representation of the binary for the base 10 number 100, 
         i.e. 1100100.
        */