¿Hay "0b" o algo similar para representar un número binario en Javascript

Sé que 0xes un prefijo para números hexadecimales en Javascript. Por ejemplo, 0xFFrepresenta el número 255.

¿Hay algo similar para los números binarios? Esperaría 0b1111representar el número 15, pero esto no funciona para mí.

Actualizar:

Las versiones más recientes de JavaScript, específicamente ECMAScript 6, han agregado soporte para literales numéricos binarios (prefijo 0b), octales (prefijo 0o) y hexadecimales (prefijo 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

Esta característica ya está disponible en Firefox y Chrome. Actualmente no es compatible con IE, pero aparentemente lo será cuando llegue Spartan.

(Gracias a Punto y coma comentario 's y la respuesta de Urish por señalar esto.)

Respuesta original

No, no hay un equivalente para números binarios. JavaScript solo admite literales numéricos en formatos decimal (sin prefijo), hexadecimal (prefijo 0x) y octal (prefijo 0).

Una alternativa posible es pasar una cadena binaria al parseIntmétodo junto con la raíz:

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

En ECMASCript 6, esto se admitirá como parte del lenguaje, 0b1111 === 15es decir, es cierto. También puede usar una B mayúscula (por ejemplo 0B1111).

Busque NumericLiteralsen la especificación ES6 .

Sé que la gente dice que extender los prototipos no es una buena idea, pero ha sido tu guión ...

Lo hago de esta manera:

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

Si su principal preocupación es la visualización en lugar de la codificación, hay un sistema de conversión incorporado que puede 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: Referencia de número de JavaScript

Hasta donde yo sé, no es posible usar un denoter binario en Javascript. Tengo tres soluciones para usted, todas las cuales tienen sus problemas. Creo que la alternativa 3 es la más "atractiva" para la legibilidad, y posiblemente sea mucho más rápida que el resto, excepto por su costo inicial de tiempo de ejecución. El problema es que solo admite valores de hasta 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 versión le permite escribir binarios de 8 dígitos b00000000, 4 dígitos b0000y dígitos variables b0. Eso es b01ilegal, tienes que usar b0001o 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;

Puede ser esto útil:

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

No, pero puede usar parseInt y, opcionalmente, omitir las comillas.

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

La única desventaja de omitir las comillas es que, para números muy grandes, se desbordará más rápido:

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

Convierta cadenas binarias a números y viceversa.

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

Sé que esto realmente no responde la pregunta Q (que ya fue respondida varias veces) como es, sin embargo, sugiero que usted (u otras personas interesadas en este tema) consideren el hecho de que es más legible y compatible con el navegador sería usar la representación hexadecimal.

De la redacción de la Q parecería que solo está hablando de usar literales binarios en su código y no procesar representaciones binarias de valores numéricos (para lo cual parstInt es el camino a seguir).

Dudo que haya muchos programadores que necesiten manejar números binarios que no estén familiarizados con el mapeo de 0-F afont>1111. básicamente, haga grupos de cuatro y use notación hexadecimal.

entonces, en lugar de escribir 101000000010, usaría 0xA02, que tiene exactamente el mismo significado y es mucho más legible y tiene menos probabilidades de tener errores.

Solo considere la legibilidad, intente comparar cuál de ellos es más grande:
10001000000010010 o 1001000000010010

y si los escribo así:
0x11012 o 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; }
}