C'è "0b" o qualcosa di simile per rappresentare un numero binario in Javascript

So che 0xè un prefisso per numeri esadecimali in Javascript. Ad esempio, 0xFFsta per il numero 255.

C'è qualcosa di simile per i numeri binari? Mi aspetto 0b1111di rappresentare il numero 15, ma questo non funziona per me.

Aggiornare:

Le versioni più recenti di JavaScript - in particolare ECMAScript 6 - hanno aggiunto il supporto per valori letterali numerici binari (prefisso 0b), ottali (prefisso 0o) ed esadecimali (prefisso 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

Questa funzione è già disponibile in Firefox e Chrome. Al momento non è supportato in IE, ma apparentemente lo sarà quando arriva Spartan.

(Grazie a virgola commento s' e la risposta di urish per la precisazione.)

Risposta originale:

No, non esiste un equivalente per i numeri binari. JavaScript supporta solo valori letterali numerici in formato decimale (senza prefisso), esadecimale (prefisso 0x) e ottale (prefisso 0).

Un'alternativa possibile è passare una stringa binaria al parseIntmetodo insieme al radix:

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

In ECMASCript 6 questo sarà supportato come parte della lingua, cioè 0b1111 === 15è vero. Puoi anche usare una B maiuscola (ad es 0B1111.).

Cercare NumericLiteralsnelle specifiche ES6 .

So che la gente dice che l'estensione dei prototipi non è una buona idea, ma è stata la tua sceneggiatura ...

Lo faccio in questo modo:

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 la tua preoccupazione principale è la visualizzazione piuttosto che la codifica, c'è un sistema di conversione integrato che puoi usare:

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

Rif: riferimento numerico JavaScript

Per quanto ne so, non è possibile utilizzare un denotatore binario in Javascript. Ho tre soluzioni per te, tutte con i loro problemi. Penso che l'alternativa 3 sia la più "bella" per la leggibilità, ed è probabilmente molto più veloce delle altre, tranne per il costo iniziale di runtime. Il problema è che supporta solo valori fino a 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

Questa versione consente di digitare 8 cifre binarie b00000000, 4 cifre b0000e cifre variabili b0. Questo è b01illegale, devi usare 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;

Può essere utile:

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

No, ma puoi usare parseInt e, facoltativamente, omettere le virgolette.

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

L'unico svantaggio di omettere le virgolette è che, per numeri molto grandi, traboccerai più velocemente:

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

Converti stringhe binarie in numeri e 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";
};

So che questo in realtà non risponde alla domanda Q (alla quale è già stata data una risposta più volte) così com'è, tuttavia suggerisco che tu (o altri interessati a questo argomento) consideri il fatto che il più leggibile e retroattivo / futuro / compatibile con più browser il modo sarebbe semplicemente usare la rappresentazione esadecimale.

Dal fraseggio di Q sembrerebbe che tu stia solo parlando dell'uso di letterali binari nel tuo codice e non dell'elaborazione di rappresentazioni binarie di valori numerici (per i quali è la strada da percorrere).

Dubito che ci siano molti programmatori che hanno bisogno di gestire numeri binari che non hanno familiarità con la mappatura di 0-F a utilizzare1111. quindi fondamentalmente crea gruppi di quattro e usa la notazione esadecimale.

quindi invece di scrivere 101000000010 useresti 0xA02 che ha esattamente lo stesso significato ed è molto più leggibile e meno probabilità di avere errori.

Considera solo la leggibilità, prova a confrontare quale di questi è più grande:
10001000000010010 o 1001000000010010

e se le scrivo in questo modo:
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; }
}