Есть ли "0b" или что-то подобное, чтобы представлять двоичное число в Javascript

Ответ 1

Update:

Более новые версии JavaScript, в частности ECMAScript 6, добавили поддержку бинарных (префикс 0b) и восьмеричных (префикс 0o) числовых литералов:

var foo = 0b1111;    // foo will be set to 15
var bar = 0o17;      // bar will be set to 15

Эта функция уже доступна в Firefox и Chrome. В настоящее время он не поддерживается в IE, но, по-видимому, будет, когда придет спартанец.

(Спасибо Semicolon и сообщить о том, как это сделать.)

Исходный ответ:

Нет, для двоичных чисел нет эквивалента. JavaScript поддерживает только числовые литералы в десятичных (без префикса), шестнадцатеричных (префикс 0x) и восьмеричных (префикс 0) форматах.

Одна из возможных альтернатив - передать двоичную строку методу parseInt вместе с основанием:

var foo = parseInt('1111', 2);    // foo will be set to 15

Ответ 2

В ECMASCript 6 это будет поддерживаться как часть языка, т.е. 0b1111 === 15 истинно. Вы также можете использовать прописную букву B (например, 0B1111).

Найдите BinaryIntegerLiteral в ES6 Spec Draft.

Ответ 3

Если ваша основная проблема заключается в отображении, а не в кодировании, есть встроенная система преобразования, которую вы можете использовать:

var num = 255;
document.writeln(num.toString(16)); // Outputs: "ff"
document.writeln(num.toString(8)); // Outputs: "377"
document.writeln(num.toString(2)); // Outputs: "11111111"

Ссылка: Ссылка на номер JavaScript

Ответ 4

Я знаю, что люди говорят, что продление прототипов не является хорошей идеей, но было вашим script...

Я делаю так:

Object.defineProperty(Number.prototype, 'b', {set:function(){return false;},get:function(){return parseInt(this, 2);}});

100..b       // returns 4
11111111..b  // returns 511
10..b+1      // returns 3

// and so on

Ответ 5

Насколько я знаю, в Javascript нельзя использовать двоичный указатель. У меня есть три решения для вас, у всех есть свои проблемы. Я думаю, что альтернатива 3 является наиболее "хорошо выглядящей" для удобочитаемости, и она, возможно, намного быстрее, чем остальные, за исключением начальной стоимости времени выполнения. Проблема в том, что он поддерживает только до 255.

Альтернатива 1: "00001111".b()

String.prototype.b = function() { return parseInt(this,2); }

Альтернатива 2: b("00001111")

function b(i) { if(typeof i=='string') return parseInt(i,2); throw "Expects string"; }

Альтернатива 3: b00001111

Эта версия позволяет ввести либо 8-значный двоичный b00000000, 4-значный b0000 и переменные цифры b0. То есть b01 является незаконным, вы должны использовать b0001 или b1.

String.prototype.lpad = function(padString, length) {
    var str = this;
    while (str.length < length)
        str = padString + str;
    return str;
}
for(var i = 0; i < 256; i++)
    window['b' + i.toString(2)] = window['b' + i.toString(2).lpad('0', 8)] = window['b' + i.toString(2).lpad('0', 4)] = i;

Ответ 6

Возможно, это будет полезно:

var bin = 1111;
var dec = parseInt(bin, 2);
// 15

Ответ 7

Преобразование двоичных строк в числа и наоборот.

var b = function(n) {
    if(typeof n === 'string')
        return parseInt(n, 2);
    else if (typeof n === 'number')
        return n.toString(2);
    throw "unknown input";
};

Ответ 8

Нет, но вы можете использовать parseInt и необязательно опускать кавычки.

parseInt(110, 2); // this is 6 
parseInt("110", 2); // this is also 6

Единственный недостаток, заключающийся в исключении кавычек, заключается в том, что для очень больших чисел вы будете быстрее переполняться:

parseInt(10000000000000000000000, 2); // this gives 1
parseInt("10000000000000000000000", 2); // this gives 4194304

Ответ 9

Я знаю, что это фактически не отвечает на заданный вопрос Q (на который уже ответили несколько раз), как есть, однако я предлагаю вам (или другим, заинтересованным в этом вопросе) учитывать тот факт, что наиболее читаемый и обратный/будущий/крест совместимый с браузером способ состоит в том, чтобы просто использовать шестнадцатеричное представление.

Из фразы Q кажется, что вы говорите только об использовании бинарных литералов в своем коде и не обрабатываете двоичные представления числовых значений (для которых parstInt - это путь).

Я сомневаюсь, что есть много программистов, которым нужно обрабатывать двоичные числа, которые не знакомы с отображением 0-F в 0000-1111. так что в основном сделать группы из четырех и использовать шестнадцатеричную нотацию.

поэтому вместо того, чтобы писать 101000000010, вы должны использовать 0xA02, который имеет точно такое же значение и является гораздо более читаемым и менее реже иметь ошибки.

Просто рассмотрите читаемость, попробуйте сравнить, какая из них больше:
10001000000010010 или 1001000000010010

и что, если я напишу их вот так:
0x11012 или 0x9012

Ответ 10

// Conversion function
function bin(nb)
{
    return parseInt(nb.toString(2));
}

// Test
var stop = false;
while(!stop)
{
    var n = parseInt(prompt("Type a decimal number : "));
    alert(bin(n));

    var str = prompt("Retry ? Y / N");
    if(str === "N") { stop = true; }
}