Gibt es "0b" oder ähnliches, um eine Binärzahl in Javascript darzustellen?

Ich weiß, dass dies 0xein Präfix für Hexadezimalzahlen in Javascript ist. Zum Beispiel 0xFFsteht für die Nummer 255.

Gibt es etwas Ähnliches für Binärzahlen? Ich würde erwarten 0b1111, die Nummer zu repräsentieren 15, aber das funktioniert bei mir nicht.

Aktualisieren:

Neuere Versionen von JavaScript - insbesondere ECMAScript 6 - bieten Unterstützung für binäre (Präfix 0b), oktale (Präfix 0o) und hexadezimale (Präfix 0x:) numerische Literale:

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

Diese Funktion ist bereits in Firefox und Chrome verfügbar. Es wird derzeit im IE nicht unterstützt, wird aber anscheinend sein, wenn Spartan eintrifft.

(Dank Semikolon ‚s Kommentar und Antwort des urish für diesen Hinweis.)

Ursprüngliche Antwort:

Nein, es gibt kein Äquivalent für Binärzahlen. JavaScript unterstützt nur numerische Literale in den Formaten Dezimal (kein Präfix), Hexadezimal (Präfix 0x) und Oktal (Präfix 0).

Eine mögliche Alternative besteht darin, eine binäre Zeichenfolge parseIntzusammen mit dem Radix an die Methode zu übergeben:

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

In ECMASCript 6 wird dies als Teil der Sprache unterstützt, dh es 0b1111 === 15ist wahr. Sie können auch Großbuchstaben B (z 0B1111. B. ) verwenden.

Suchen Sie NumericLiteralsin der ES6-Spezifikation .

Ich weiß, dass die Leute sagen, dass die Erweiterung der Prototypen keine gute Idee ist, sondern Ihr Drehbuch ...

Ich mache es so:

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

Wenn Ihr Hauptanliegen eher die Anzeige als die Codierung ist, können Sie ein integriertes Konvertierungssystem verwenden:

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-Nummernreferenz

Soweit ich weiß, ist es nicht möglich, einen binären Denoter in Javascript zu verwenden. Ich habe drei Lösungen für Sie, die alle ihre Probleme haben. Ich denke, Alternative 3 sieht in Bezug auf die Lesbarkeit am besten aus und ist möglicherweise viel schneller als die anderen - abgesehen von den anfänglichen Laufzeitkosten. Das Problem ist, dass nur Werte bis zu 255 unterstützt werden.

Alternative 1: "00001111".b()

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

Alternative 2: b("00001111")

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

Alternative 3: b00001111

In dieser Version können Sie entweder 8-stellige binäre b00000000, 4-stellige b0000und variable Ziffern eingeben b0. Das ist b01illegal, muss man benutzen b0001oder 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;

Vielleicht ist dies nützlich:

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

Nein, aber Sie können parseInt verwenden und optional die Anführungszeichen weglassen.

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

Der einzige Nachteil beim Weglassen der Anführungszeichen besteht darin, dass Sie bei sehr großen Zahlen schneller überlaufen:

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

Konvertieren Sie binäre Zeichenfolgen in Zahlen und umgekehrt.

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

Ich weiß, dass dies das gestellte Q (das bereits mehrmals beantwortet wurde) nicht so beantwortet, wie es ist. Ich schlage jedoch vor, dass Sie (oder andere an diesem Thema interessierte Personen) die Tatsache berücksichtigen, dass es am besten lesbar und rückwärts / zukünftig / browserübergreifend kompatibel ist Weg wäre, nur die Hex-Darstellung zu verwenden.

Aus der Formulierung des Q geht hervor, dass Sie nur über die Verwendung von Binärliteralen in Ihrem Code und nicht über die Verarbeitung von Binärdarstellungen numerischer Werte sprechen (für die parstInt der richtige Weg ist).

Ich bezweifle, dass es viele Programmierer gibt, die mit Binärzahlen umgehen müssen, die mit der Zuordnung von 0-F zu 0000-1111 nicht vertraut sind. Bilden Sie also im Grunde Vierergruppen und verwenden Sie die Hex-Notation.

Anstatt 101000000010 zu schreiben, würden Sie 0xA02 verwenden, das genau die gleiche Bedeutung hat, weitaus besser lesbar ist und weniger fehleranfällig ist.

Denken Sie nur an die Lesbarkeit. Vergleichen Sie, welche davon größer ist: 10001000000010010 oder 1001000000010010

und was ist, wenn ich sie so schreibe:
0x11012 oder 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; }
}