Apakah ada "0b" atau sesuatu yang mirip dengan mewakili angka biner di Javascript

Saya tahu itu 0xadalah awalan untuk angka heksadesimal dalam Javascript. Misalnya, 0xFFsingkatan dari angka 255.

Apakah ada yang serupa dengan angka biner? Saya berharap 0b1111untuk mewakili nomornya 15, tetapi ini tidak berhasil untuk saya.

Memperbarui:

Versi JavaScript yang lebih baru - khususnya ECMAScript 6 - telah menambahkan dukungan untuk biner (awalan 0b), oktal (awalan 0o) dan heksadesimal (awalan 0x:) literal angka:

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

Fitur ini sudah tersedia di Firefox dan Chrome. Saat ini tidak didukung di IE, tetapi tampaknya akan ketika Spartan tiba.

(Terima kasih atas komentar Semicolon dan jawaban urish untuk menunjukkan hal ini.)

Jawaban asli:

Tidak, tidak ada yang setara dengan angka biner. JavaScript hanya mendukung literal angka dalam format desimal (tanpa awalan), heksadesimal (awalan 0x) dan oktal (awalan 0).

Salah satu alternatif yang mungkin adalah meneruskan string biner ke parseIntmetode bersama dengan radix:

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

Dalam ECMASCript 6 ini akan didukung sebagai bagian dari bahasa, yaitu 0b1111 === 15benar. Anda juga dapat menggunakan huruf kapital B (mis 0B1111.).

Cari NumericLiteralsdi dalam ES6 Spec .

Saya tahu bahwa orang mengatakan bahwa memperluas prototipe bukan ide yang baik, tetapi sudah menjadi skrip Anda ...

Saya melakukannya dengan cara ini:

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

Jika masalah utama Anda adalah tampilan alih-alih pengkodean, ada sistem konversi bawaan yang dapat Anda gunakan:

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: Referensi Nomor JavaScript

Sejauh yang saya tahu tidak mungkin menggunakan denoter biner di Javascript. Saya punya tiga solusi untuk Anda, yang semuanya memiliki masalah. Saya pikir alternatif 3 adalah yang paling "tampan" untuk keterbacaan, dan mungkin jauh lebih cepat daripada yang lain - kecuali untuk biaya waktu menjalankan awal. Masalahnya hanya mendukung nilai hingga 255.

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

Versi ini memungkinkan Anda mengetik 8 digit biner b00000000, 4 digit, b0000dan digit variabel b0. Itu b01ilegal, Anda harus menggunakan b0001atau 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;

Semoga ini bermanfaat:

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

Tidak, tetapi Anda dapat menggunakan parseInt dan secara opsional menghilangkan tanda kutip.

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

Satu-satunya kelemahan dari menghilangkan tanda kutip adalah bahwa, untuk jumlah yang sangat besar, Anda akan meluap lebih cepat:

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

Mengonversi string biner menjadi angka dan sebaliknya.

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

Saya tahu ini tidak benar-benar menjawab Q yang ditanyakan (yang sudah dijawab beberapa kali) sebagaimana adanya, namun saya sarankan Anda (atau orang lain yang tertarik pada subjek ini) mempertimbangkan fakta bahwa browser yang paling mudah dibaca & mundur / masa depan / lintas-browser-kompatibel cara adalah dengan hanya menggunakan representasi hex.

Dari frasa dari Q akan tampak bahwa Anda hanya berbicara tentang menggunakan literal biner dalam kode Anda dan tidak memproses representasi biner dari nilai numerik (yang parstInt adalah cara untuk pergi).

Saya ragu bahwa ada banyak programmer yang perlu menangani angka biner yang tidak terbiasa dengan pemetaan 0-F hingga 0000-1111. jadi pada dasarnya buat kelompok empat dan gunakan notasi hex.

jadi alih-alih menulis 101000000010 Anda akan menggunakan 0xA02 yang memiliki arti yang persis sama dan jauh lebih mudah dibaca dan lebih kecil kemungkinannya untuk memiliki kesalahan.

Perhatikan saja keterbacaan, Coba bandingkan mana yang lebih besar: 10001000000010010 atau 1001000000010010

dan bagaimana jika saya menulisnya seperti ini:
0x11012 atau 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; }
}