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

Question

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

Esiste qualcosa di simile per i numeri binari? Mi aspetto che 0b1111 rappresenti il ​​numero 15, ma questo non funziona per me.

Answer 1

Aggiornamento:

recenti versioni di JavaScript - supporto si sono aggiunti per il binario (prefisso 0b) e ottale (prefisso 0o) costanti numeriche - specificamente ECMAScript 6:

var foo = 0b1111; // foo will be set to 15 
var bar = 0o17;  // bar will be set to 15 

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

(Grazie a commentare Semicolon s' e urish's answer per la precisazione.)

risposta originale:

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

Una possibile alternativa è quella di passare una stringa binaria al metodo parseInt insieme con la radice:

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

Answer 2

Se la vostra preoccupazione principale è di visualizzazione piuttosto che codifica, c'è un sistema integrato di conversione è possibile utilizzare:

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: JavaScript Number Reference

Answer 3

Può essere questo sarà utile:

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

Answer 4

Per quanto ne so non è possibile utilizzare un denoter binario in Javascript. Ho tre soluzioni per te, tutte con i loro problemi. Penso che l'alternativa 3 sia la più "di bell'aspetto" per la leggibilità, ed è probabilmente molto più veloce del resto - tranne che per il suo costo iniziale di esecuzione. 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 binario a 8 cifre , 4 cifre b0000 e variab le cifre b0. Questo è b01 è illegale, è necessario utilizzare b0001 o 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; 

Answer 5

So che la gente dice che estendere i prototipi non è una buona idea, ma stato lo script ...

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 

Answer 6

Convertire stringhe binarie a numeri e visa-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"; 
}; 

Answer 7

In EcmaScript 6 sarà supportato come parte del linguaggio, cioè 0b1111 === 15 è vero. Puoi anche utilizzare una B maiuscola (ad esempio 0B1111).

Cerca BinaryIntegerLiteral nello ES6 Spec Draft.

Answer 8

No, ma è possibile utilizzare 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, si traboccare più veloce:

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

Answer 9

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

Answer 10

So che questo in realtà non rispondere alla domanda Q (che era ho già risposto diverse volte), tuttavia, suggerisco che tu (o altri interessati a questo argomento) consideri il fatto che il modo più leggibile con il backward/future/cross browser compatibile sia & semplicemente utilizzare la rappresentazione esadecimale.

Dal fraseggio della Q sembrerebbe che si stia parlando solo dell'utilizzo di valori letterali binari nel proprio codice e non dell'elaborazione di rappresentazioni binarie di valori numerici (per i quali parstInt è 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 suaneo1111. quindi fai gruppi di quattro e usa la notazione esadecimale.

così invece di scrivere 101000000010 si userebbe 0xA02 che ha esattamente lo stesso significato ed è molto più leggibile e meno probabile che abbia errori.

Basti pensare leggibilità, provare a confronto, che di quelli è più grande:
10001000000010010 o 1001000000010010

e che cosa se li scrivo in questo modo:
0x11012 o 0x9012