Есть ли «0b» или что-то подобное для представления двоичного числа в Javascript?

Я знаю, что 0xэто префикс для шестнадцатеричных чисел в Javascript. Например, 0xFFэто число 255.

Есть ли что-то подобное для двоичных чисел? Я ожидал 0b1111представить число 15, но это не работает для меня.

Обновить:

В новых версиях JavaScript, в частности в ECMAScript 6, добавлена ​​поддержка двоичных (префикс 0b), восьмеричных (префикс 0o) и шестнадцатеричных (префикс 0x:) числовых литералов:

var bin = 0b1111;    // bin will be set to 15
var oct = 0o17;      // oct will be set to 15
var oxx = 017;       // oxx will be set to 15
var hex = 0xF;       // hex will be set to 15
// note: bB oO xX are all valid

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

(Спасибо комментарию точки с запятой и ответу за указание на это.)

Оригинальный ответ:

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

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

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

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

Ищите NumericLiteralsв спецификации ES6 .

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

Я так делаю:

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

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

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

Насколько мне известно, в 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;

Может быть, это пригодится:

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

Нет, но вы можете использовать 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

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

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

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

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

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

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

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

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

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