Is er “0b” of iets dergelijks om een ​​binair getal in Javascript te vertegenwoordigen

Ik weet dat 0xeen prefix is ​​voor hexadecimale getallen in Javascript. 0xFFstaat bijvoorbeeld voor het getal 255.

Is er iets soortgelijks voor binaire getallen? Ik zou verwachten dat 0B1111het getal 15vertegenwoordigt, maar dit werkt niet voor mij.

Antwoord 1, autoriteit 100%

Bijwerken:

Nieuwere versies van JavaScript — met name ECMAScript 6 — hebben ondersteuning toegevoegd voor binair (prefix 0b), octaal (prefix 0o) en hexadecimaal (prefix: 0x) numerieke letterlijke waarden:

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

Deze functie is al beschikbaar in Firefox en Chrome. Het wordt momenteel niet ondersteund in IE, maar zal dat blijkbaar wel zijn wanneer Spartan arriveert.

(Met dank aan puntkomma‘s opmerking en urish’s antwoordom hierop te wijzen.)

Oorspronkelijk antwoord:

Nee, er is geen equivalent voor binaire getallen. JavaScript ondersteunt alleen numerieke literals in decimale (geen prefix), hexadecimale (prefix 0x) en octale (prefix 0) formaten.

Een mogelijk alternatief is om een ​​binaire string door te geven aan de parseIntmethode samen met de radix:

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

Antwoord 2, autoriteit 15%

In ECMASCript 6 wordt dit ondersteund als onderdeel van de taal, d.w.z. 0b1111 === 15is waar. U kunt ook een hoofdletter B gebruiken (bijv. 0B1111).

Zoek naar NumericLiteralsin de ES6-specificatie.

Antwoord 3, autoriteit 11%

Ik weet dat mensen zeggen dat het uitbreiden van de prototypes geen goed idee is, maar het is jouw script geweest…

Ik doe het op deze manier:

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

Antwoord 4, autoriteit 10%

Als uw voornaamste zorg display is in plaats van coderen, is er een ingebouwd conversiesysteem dat u kunt gebruiken:

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: MDN op Number.prototype.toString

Antwoord 5, autoriteit 4%

Voor zover ik weet is het niet mogelijk om een ​​binaire aanduiding te gebruiken in Javascript. Ik heb drie oplossingen voor je, die allemaal hun problemen hebben. Ik denk dat alternatief 3 het “mooiste” is wat betreft leesbaarheid, en het is mogelijk veel sneller dan de rest – behalve de initiële runtime-kosten. Het probleem is dat het alleen waarden tot 255 ondersteunt.

Alternatief 1: "00001111".b()

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

Alternatief 2: b("00001111")

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

Alternatief 3: b00001111

In deze versie kun je 8-cijferige binaire b00000000, 4-cijferige b0000en variabele cijfers b0typen. Dat wil zeggen dat b01illegaal is, je moet b0001of b1gebruiken.

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;

Antwoord 6, autoriteit 2%

Misschien is dit nuttig:

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

Antwoord 7

Zet binaire tekenreeksen om in cijfers en omgekeerd.

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

Antwoord 8

Nee, maar je kunt parseInt gebruiken en eventueel de aanhalingstekens weglaten.

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

Het enige nadeel van het weglaten van aanhalingstekens is dat u bij zeer grote getallen sneller overloopt:

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

Antwoord 9

Ik weet dat dit niet echt een antwoord is op de gestelde Q (die al verschillende keren is beantwoord), maar ik stel voor dat u (of anderen die geïnteresseerd zijn in dit onderwerp) het feit overwegen dat de meest leesbare & achterwaartse/toekomstige/cross browser-compatibele manier zou zijn om gewoon de hexadecimale weergave te gebruiken.

Uit de bewoording van de Q lijkt het alsof je het alleen hebt over het gebruik van binaire letterlijke waarden in je code en niet over het verwerken van binaire representaties van numerieke waarden (waarvoor parstInt de juiste keuze is).

Ik betwijfel of er veel programmeurs zijn die binaire getallen moeten afhandelen die niet bekend zijn met de toewijzing van 0-F aan 0000-1111.
dus maak in principe groepen van vier en gebruik de hexadecimale notatie.

dus in plaats van 101000000010 te schrijven, zou je 0xA02 gebruiken, wat precies dezelfde betekenis heeft en veel leesbaarder is en minder kans heeft op fouten.

Overweeg de leesbaarheid, probeer te vergelijken welke van de twee groter is:
10001000000010010 of 1001000000010010

en wat als ik ze zo schrijf:
0x11012 of 0x9012

Antwoord 10

De functie Number() gebruiken werkt…

// using Number() 
var bin = Number('0b1111');    // bin will be set to 15
var oct = Number('0o17');      // oct will be set to 15
var oxx = Number('0xF');       // hex will be set to 15
// making function convTo
const convTo = (prefix,n) => {
  return Number(`${prefix}${n}`) //Here put prefix 0b, 0x and num
}
console.log(bin)
console.log(oct)
console.log(oxx)
// Using convTo function
console.log(convTo('0b',1111))