Я хотел бы видеть целые числа, положительные или отрицательные, в двоичном виде.
Скорее как этот вопрос , но для JavaScript.
javascript
numbers
barlop
источник
источник
Ответы:
Вы можете использовать
Number.toString(2)
функцию, но у нее есть некоторые проблемы при представлении отрицательных чисел. Например,(-1).toString(2)
вывод есть"-1"
.Чтобы решить эту проблему, вы можете использовать битовый оператор беззнакового сдвига вправо (
>>>
), чтобы привести ваш номер к целому числу без знака.Если вы запустите,
(-1 >>> 0).toString(2)
вы сдвинете свои биты числа 0 вправо, что само по себе не изменит число, но будет представлено как целое число без знака. Код выше выведет"11111111111111111111111111111111"
правильно.Этот вопрос имеет дальнейшее объяснение.
источник
Пытаться
2 является основанием и может быть любым основанием от 2 до 36
источник здесь
ОБНОВИТЬ:
Это будет работать только для положительных чисел, Javascript представляет отрицательные двоичные целые числа в двоичной записи. Я сделал эту маленькую функцию, которая должна была сделать свое дело, я не проверил это должным образом:
Я получил некоторую помощь отсюда
источник
-3
возврат1
). Также я считаю, чтоdec > 0
должно бытьdec >= 0
, которое должно по крайней мере исправить 0. Потому чтоdec2Bin(0)
возвращается10
.Двоичный файл в «преобразовать в двоичный» может относиться к трем основным вещам. Позиционная система счисления, двоичное представление в памяти или 32-битные цепочки битов. (для 64-битных цепочек см. ответ Патрика Робертса )
1. Система счисления
(123456).toString(2)
преобразует числа в основную 2-х позиционную систему счисления . В этой системе отрицательные числа пишутся со знаками минус, как в десятичной.2. Внутреннее Представительство
Внутреннее представление чисел - 64-битная с плавающей запятой, и в этом ответе обсуждаются некоторые ограничения . Нет простого способа создать представление битовой строки в javascript или получить доступ к конкретным битам.
3. Маски и побитовые операторы
MDN имеет хороший обзор того, как работают побитовые операторы. Важно отметить:
Перед применением операций 64-разрядные числа с плавающей запятой приводятся к 32-разрядным целым числам со знаком. После они обращены обратно.
Вот пример кода MDN для преобразования чисел в 32-битные строки.
источник
Простой способ это просто ...
источник
(42).toString(2)
42..toString(2)
1.
то же, что1.0
или просто1
(и аналогично вы можете опустить часть раньше и написать.5
вместо0.5
). Таким образом, в примере первая точка - это десятичный разделитель, который является частью числа, а вторая точка - это оператор точки для вызова метода для этого числа. Вы должны использовать две точки (или заключить число в круглые скобки) и не можете просто написать,42.toString(2)
потому что анализатор видит точку как десятичный разделитель и выдает ошибку из-за пропущенного оператора точки.Этот ответ пытается адресовать входы с абсолютным значением в диапазоне 2147483648 10 (2 31 ) - 9007199254740991 10 (2 53 -1).
В JavaScript числа хранятся в 64-битном представлении с плавающей запятой , но побитовые операции приводят их к 32-битным целым числам в формате дополнения до двух , поэтому любой подход, использующий побитовые операции, ограничивает диапазон вывода до -2147483648 10 (-2 31 ) - 2147483647 10 (2 31 -1).
Однако, если побитовые операции исключаются и 64-битное представление с плавающей запятой сохраняется с использованием только математических операций, мы можем надежно преобразовать любое безопасное целое число в 64-битную двоичную запись дополнения до двух, расширяя знак 53-бит
twosComplement
:В старых браузерах существуют полифилы для следующих функций и значений:
Number.isSafeInteger()
Number.isInteger()
Number.MAX_SAFE_INTEGER
String.prototype.padStart()
В качестве дополнительного бонуса вы можете поддержать любое основание (2–36), если выполните преобразование дополнения до двух для отрицательных чисел в ⌈64 / log 2 (основание) ⌉, используя
BigInt
:Если вас интересует мой старый ответ, в котором
ArrayBuffer
для создания союза между aFloat64Array
и a использовался знак «Uint16Array
пожалуйста», обратитесь к истории изменений этого ответа .источник
-(2**53)-1
чтобы2**53-1
вместо того , чтобы просто ,-(2**31)
чтобы2**31-1
как ответ Аннана.Решение, которое я выбрал бы для 32-битного кода, - это конец этого ответа, код от developer.mozilla.org (MDN), но с некоторыми добавленными строками для A) форматирования и B) проверки того, что номер находится в диапазоне.
Некоторые предположили,
x.toString(2)
что это не работает для негативов, для них просто вставляется знак минус, что бесполезно.Фернандо упомянул простое решение,
(x>>>0).toString(2);
которое подходит для негативов, но имеет небольшую проблему, когда х положительно. Вывод начинается с 1, что для положительных чисел не является правильным дополнением 2s.Любой, кто не понимает факт положительных чисел, начинающихся с 0 и отрицательных чисел с 1, в дополнении 2s, может проверить эту SO QnA на дополнении 2s. Что такое «дополнение 2»?
Решение может заключаться в добавлении 0 для положительных чисел, что я и сделал в более ранней редакции этого ответа. И иногда можно принять 33-битное число или убедиться, что конвертируемое число находится в пределах диапазона - (2 ^ 31) <= x <2 ^ 31-1. Таким образом, число всегда составляет 32 бита. Но вместо того, чтобы сделать это, вы можете пойти с этим решением на mozilla.org
Ответ и код Патрика длинный и, по-видимому, работает для 64-битной системы, но имел ошибку, которую нашел комментатор, и комментатор исправил ошибку Патрика, но у Патрика в коде есть какое-то «магическое число», о котором он не комментировал и имеет о котором забыли, и Патрик больше не полностью понимает свой собственный код / почему он работает.
У Аннана была неправильная и неясная терминология, но он упомянул решение от developer.mozilla.org https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators. Это работает для 32-разрядных чисел.
Код довольно компактный, функция из трех строк.
Но я добавил регулярное выражение для форматирования вывода в группы по 8 бит. Основано на том, как напечатать число с запятыми в качестве разделителей тысяч в JavaScript (я только что изменил его: сгруппировать его в 3 с справа налево и добавить запятые , сгруппировать в 8 с справа налево и добавить пробелы )
И хотя mozilla прокомментировала размер nMask (число вводимых) ... что он должен находиться в диапазоне, они не проверяли и не выдавали ошибку, когда число выходит за пределы диапазона, поэтому я добавил это.
Я не уверен, почему они назвали свой параметр 'nMask', но я оставлю это как есть.
Ссылка: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators
источник
Вы можете написать свою собственную функцию, которая возвращает массив битов. Пример как преобразовать число в биты
Делитель | Дивидендная | бит / остаточный
2 | 9 | 1
2 | 4 | 0
2 | 2 | 0
~ | 1 | ~
Пример вышеприведенной строки: 2 * 4 = 8, а остаток равен 1, поэтому 9 = 1 0 0 1
Читайте остатки снизу вверх. Цифра 1 посередине вверх.
источник
Math.floor(number%2)
вместоnumber = Math.floor(number/2)
?Я использовал другой подход, чтобы придумать что-то, что делает это. Я решил не использовать этот код в своем проекте, но я решил оставить его где-нибудь актуальным на случай, если он кому-нибудь пригодится.
источник
Еще одна альтернатива
источник
Это мой код:
источник
Это решение. Это довольно просто на самом деле
источник