มี“ 0b” หรือสิ่งที่คล้ายกับแทนเลขฐานสองใน Javascript

ฉันรู้ว่านั่น0xคือคำนำหน้าสำหรับเลขฐานสิบหกใน Javascript ตัวอย่างเช่น0xFFย่อมาจากเลข 255

มีอะไรที่คล้ายกันสำหรับเลขฐานสองหรือไม่? ฉันคาดหวังว่า0b1111จะเป็นตัวแทนของตัวเลข15แต่มันไม่ได้ผลสำหรับฉัน

ปรับปรุง:

JavaScript เวอร์ชันใหม่กว่า - โดยเฉพาะ ECMAScript 6 - ได้เพิ่มการรองรับไบนารี (คำนำหน้า0b), ฐานแปด (คำนำหน้า0o) และเลขฐานสิบหก (คำนำหน้า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

คุณลักษณะนี้มีอยู่แล้วใน Firefox และ Chrome ขณะนี้ยังไม่รองรับ IE แต่ดูเหมือนว่าจะเป็นเมื่อ Spartan มาถึง

(ขอบคุณความคิดเห็นของอัฒภาคและคำตอบของ urish ที่ชี้ให้เห็นสิ่งนี้)

คำตอบเดิม:

ไม่ไม่มีเลขฐานสองเทียบเท่า JavaScript รองรับเฉพาะอักษรตัวเลขในรูปแบบทศนิยม (ไม่มีคำนำ0xหน้า0) รูปแบบเลขฐานสิบหก (คำนำหน้า) และฐานแปด (คำนำหน้า)

ทางเลือกหนึ่งที่เป็นไปได้คือการส่งสตริงไบนารีไปยังparseIntเมธอดพร้อมกับเครื่องหมาย:

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

ใน ECMASCript 6 สิ่งนี้จะได้รับการสนับสนุนเป็นส่วนหนึ่งของภาษากล่าว0b1111 === 15คือเป็นจริง คุณยังสามารถใช้ตัวพิมพ์ใหญ่ B (เช่น0B1111)

มองหาNumericLiteralsในES6 Spec

ฉันรู้ว่ามีคนบอกว่าการขยายต้นแบบไม่ใช่ความคิดที่ดี แต่เป็นสคริปต์ของคุณ ...

ฉันทำแบบนี้:

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

หากข้อกังวลหลักของคุณคือการแสดงผลมากกว่าการเข้ารหัสมีระบบการแปลงในตัวที่คุณสามารถใช้ได้:

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

อ้างอิง: JavaScript Number Reference

เท่าที่ฉันรู้มันเป็นไปไม่ได้ที่จะใช้ตัวแสดงไบนารีใน Javascript ฉันมีวิธีแก้ปัญหาให้คุณสามวิธีซึ่งทั้งหมดนี้มีปัญหา ฉันคิดว่าทางเลือกที่ 3 นั้น "ดูดี" ที่สุดสำหรับความสามารถในการอ่านและอาจเร็วกว่าที่เหลืออยู่มากยกเว้นค่าใช้จ่ายในการรันไทม์เริ่มต้น ปัญหาคือรองรับค่าได้สูงสุด 255 เท่านั้น

ทางเลือกที่ 1: "00001111".b()

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

ทางเลือกที่ 2: b("00001111")

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

ทางเลือกที่ 3: b00001111

รุ่นนี้ช่วยให้คุณพิมพ์ทั้ง 8 ไบนารีหลักb000000004 หลักและตัวเลขตัวแปรb0000 b0ที่b01ผิดกฎหมายคุณต้องใช้b0001หรือ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;

อาจเป็นประโยชน์:

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

ไม่ได้ แต่คุณสามารถใช้ parseInt และไม่ใส่เครื่องหมายคำพูดก็ได้

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

ข้อเสียเพียงประการเดียวของการละเว้นเครื่องหมายคำพูดก็คือสำหรับจำนวนมากคุณจะล้นเร็วขึ้น:

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

แปลงสตริงไบนารีเป็นตัวเลขและวีซ่าในทางกลับกัน

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

ฉันรู้ว่าสิ่งนี้ไม่ได้ตอบคำถามที่ถามจริง ๆ (ซึ่งได้รับคำตอบแล้วหลายครั้ง) ตามที่เป็นอยู่อย่างไรก็ตามฉันขอแนะนำให้คุณ (หรือคนอื่น ๆ ที่สนใจในเรื่องนี้) พิจารณาข้อเท็จจริงที่ว่าเบราว์เซอร์ที่อ่านได้มากที่สุด & ย้อนกลับ / อนาคต / ข้ามเบราว์เซอร์ วิธีก็แค่ใช้การแทนค่าฐานสิบหก

จากวลีของ Q ดูเหมือนว่าคุณกำลังพูดถึงการใช้ตัวอักษรไบนารีในรหัสของคุณเท่านั้นและไม่ได้ประมวลผลการแสดงค่าตัวเลขไบนารี (ซึ่ง parstInt เป็นวิธีที่จะไป)

ฉันสงสัยว่ามีโปรแกรมเมอร์หลายคนที่ต้องจัดการเลขฐานสองที่ไม่คุ้นเคยกับการแมป 0-F ถึง 0000-1111 ดังนั้นโดยทั่วไปให้สร้างกลุ่มสี่และใช้สัญกรณ์ฐานสิบหก

ดังนั้นแทนที่จะเขียน 101000000010 คุณจะใช้ 0xA02 ซึ่งมีความหมายเหมือนกันทุกประการและอ่านง่ายกว่าและมีโอกาสเกิดข้อผิดพลาดน้อยกว่า

เพียงพิจารณาความสามารถในการอ่านลองเปรียบเทียบว่าอันไหนใหญ่กว่า:
10001000000010010 หรือ 1001000000010010

แล้วถ้าเขียนแบบนี้จะเป็นอย่างไร:
0x11012 หรือ 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; }
}