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

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

искать NumericLiterals на ES6 Spec.

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

Я делаю это так:

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"

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

насколько я знаю, это не возможно, чтобы использовать бинарные denoter в 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 и переменной digits 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 (который уже отвечал несколько раз), как есть, однако я предлагаю вам (или другим заинтересованным в этой теме) рассмотреть тот факт, что наиболее читаемым и обратно/будущим/кросс-браузерным способом было бы просто использовать шестнадцатеричное представление.

из формулировки 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; }
}