Existe "0b" ou algo semelhante para representar um número binário em Javascript

Eu sei que 0xé um prefixo para números hexadecimais em Javascript. Por exemplo, 0xFFsignifica o número 255.

Existe algo semelhante para números binários? Eu esperaria 0b1111representar o número 15, mas isso não funciona para mim.

Atualizar:

As versões mais recentes do JavaScript - especificamente o ECMAScript 6 - adicionaram suporte para literais numéricos binários (prefixo 0b), octal (prefixo 0o) e hexadecimal (prefixo 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

Esse recurso já está disponível no Firefox e Chrome. No momento, ele não é suportado no IE, mas aparentemente será quando Spartan chegar.

(Agradecemos o comentário do ponto- e- vírgula e a resposta do urish por apontar isso.)

Resposta original:

Não, não há um equivalente para números binários. O JavaScript suporta apenas literais numéricos nos formatos decimal (sem prefixo), hexadecimal (prefixo 0x) e octal (prefixo 0).

Uma alternativa possível é passar uma string binária para o parseIntmétodo junto com o radical:

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

No ECMASCript 6, isso será suportado como parte do idioma, ou seja, 0b1111 === 15é verdade. Você também pode usar um B maiúsculo (por exemplo 0B1111).

Procure NumericLiteralsnas especificações do ES6 .

Eu sei que as pessoas dizem que estender os protótipos não é uma boa ideia, mas foi seu roteiro ...

Eu faço assim:

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

Se sua principal preocupação é exibir e não codificar, existe um sistema de conversão interno que você pode usar:

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: Referência de Número JavaScript

Tanto quanto sei, não é possível usar um denotador binário em Javascript. Eu tenho três soluções para você, todas com problemas. Eu acho que a alternativa 3 é a mais "atraente" para facilitar a leitura e é possivelmente muito mais rápida que as demais - exceto pelo custo inicial do tempo de execução. O problema é que ele suporta apenas valores de até 255.

Alternativa 1: "00001111".b()

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

Alternativa 2: b("00001111")

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

Alternativa 3: b00001111

Esta versão permite que você digite 8 dígitos binários b00000000, 4 dígitos b0000e dígitos variáveis b0. Isso é b01ilegal, você tem que usar b0001ou 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;

Pode ser que isso seja útil:

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

Não, mas você pode usar parseInt e, opcionalmente, omitir as aspas.

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

A única desvantagem de omitir as aspas é que, para números muito grandes, você transbordará mais rápido:

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

Converta cadeias binárias em números e vice-versa.

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

Sei que na verdade isso não responde à pergunta Q (que já foi respondida várias vezes), como é, no entanto, sugiro que você (ou outras pessoas interessadas neste assunto) considere o fato de que os mais legíveis e compatíveis com os navegadores anteriores / futuros / cruzados maneira seria apenas usar a representação hexadecimal.

Pelo fraseado do Q, parece que você está falando apenas sobre o uso de literais binários em seu código e não sobre o processamento de representações binárias de valores numéricos (para o qual parstInt é o caminho a seguir).

Duvido que existam muitos programadores que precisam manipular números binários que não estão familiarizados com o mapeamento de 0-F para 0000-1111. então, basicamente, crie grupos de quatro e use a notação hexadecimal.

portanto, em vez de escrever 101000000010, você usaria 0xA02, que tem exatamente o mesmo significado e é muito mais legível e menos provável de ter erros.

Basta considerar a legibilidade. Tente comparar qual deles é maior:
10001000000010010 ou 1001000000010010

e se eu os escrever assim:
0x11012 ou 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; }
}