Javascript'te "0b" veya bir ikili sayıyı temsil etmeye benzer bir şey var mı

Bunun 0xJavascript'teki onaltılık sayılar için bir önek olduğunu biliyorum . Örneğin, 0xFF255 sayısını belirtir.

İkili sayılar için benzer bir şey var mı? 0b1111Numarayı temsil etmeyi beklerdim 15, ancak bu benim için çalışmıyor.

Güncelleme:

JavaScript'in daha yeni sürümleri - özellikle ECMAScript 6 - ikili (önek 0b), sekizlik (önek 0o) ve onaltılık (önek 0x:) sayısal değişmez değerler için destek ekledi :

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

Bu özellik halihazırda Firefox ve Chrome'da mevcuttur. Şu anda IE'de desteklenmiyor, ancak görünüşe göre Spartan geldiğinde olacak.

( Noktalı virgülün yorumu ve urish'in bunu işaret ettiği için cevabı sayesinde .)

Orijinal Cevap:

Hayır, ikili sayıların eşdeğeri yoktur. JavaScript yalnızca ondalık (önek yok), onaltılık (önek 0x) ve sekizlik (önek 0) biçimlerinde sayısal değişmez değerleri destekler.

Olası bir alternatif, parseIntyönteme radix ile birlikte ikili bir dize iletmektir:

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

ECMASCript 6'da bu, dilin bir parçası olarak desteklenecektir, yani 0b1111 === 15doğrudur. Ayrıca büyük B harfini de kullanabilirsiniz (örneğin 0B1111).

Arayın NumericLiteralsiçinde ES6 Spec .

İnsanların prototipleri genişletmenin iyi bir fikir olmadığını söylediğini biliyorum, ama senaryonuz oldu ...

Bunu şu şekilde yapıyorum:

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

Birincil endişeniz kodlama yerine görüntüleme ise, kullanabileceğiniz yerleşik bir dönüştürme sistemi vardır:

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 Numarası Referansı

Bildiğim kadarıyla Javascript'te ikili belirteç kullanmak mümkün değil. Sizin için hepsinin sorunları olan üç çözümüm var. Bence alternatif 3, okunabilirlik açısından en "iyi görünen" ve muhtemelen diğerlerinden çok daha hızlı - ilk çalıştırma süresi maliyeti dışında. Sorun, yalnızca 255'e kadar olan değerleri desteklemesidir.

Alternatif 1: "00001111".b()

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

Alternatif 2: b("00001111")

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

Alternatif 3: b00001111

Bu sürüm, 8 basamaklı ikili b00000000, 4 basamaklı b0000ve değişken basamaklı yazmanıza izin verir b0. Bu b01yasa dışıdır, b0001veya kullanmanız gerekir 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;

Bu yararlı olabilir:

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

Hayır, ancak parseInt kullanabilir ve isteğe bağlı olarak tırnak işaretlerini atlayabilirsiniz.

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

Teklifleri atlamanın tek dezavantajı, çok büyük sayılar için daha hızlı taşacak olmanızdır:

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

İkili dizeleri sayılara ve tam tersine dönüştürün.

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

Bunun sorulan Soruya (zaten birkaç kez yanıtlanmış olan) aslında olduğu gibi yanıt vermediğini biliyorum, ancak siz (veya bu konuyla ilgilenen diğer kişilerin) en okunabilir ve geriye doğru / gelecek / çapraz tarayıcı uyumlu olduğu gerçeğini göz önünde bulundurmanızı öneririm. yol sadece onaltılık gösterimi kullanmak olacaktır.

Q'nun ifadesine bakılırsa, sadece kodunuzda ikili değişmezleri kullanmaktan bahsediyorsunuz ve sayısal değerlerin ikili gösterimlerinin işlenmesinden değil (ki bunun için parstInt gitmenin yoludur).

0-F ile 0000-1111 arasındaki eşleştirmeye aşina olmayan ikili sayıları işlemesi gereken birçok programcı olduğundan şüpheliyim. yani temelde dörtlü gruplar yapın ve onaltılık notasyonu kullanın.

yani, 101000000010 yazmak yerine, tamamen aynı anlama sahip olan ve çok daha okunaklı ve hata yapma olasılığı daha düşük olan 0xA02'yi kullanırsınız.

Okunabilirliği bir düşünün, hangisinin daha büyük olduğunu karşılaştırmayı deneyin:
10001000000010010 veya 1001000000010010

ve bunları şöyle
yazarsam : 0x11012 veya 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; }
}