Y a-t-il «0b» ou quelque chose de similaire pour représenter un nombre binaire en Javascript

Je sais que 0xc'est un préfixe pour les nombres hexadécimaux en Javascript. Par exemple, 0xFFreprésente le nombre 255.

Y a-t-il quelque chose de similaire pour les nombres binaires? Je m'attendrais 0b1111à représenter le nombre 15, mais cela ne fonctionne pas pour moi.

Mettre à jour:

Les nouvelles versions de JavaScript - en particulier ECMAScript 6 - ont ajouté la prise en charge des littéraux numériques binaires (préfixe 0b), octal (préfixe 0o) et hexadécimaux (préfixe 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

Cette fonctionnalité est déjà disponible dans Firefox et Chrome. Il n'est actuellement pas pris en charge dans IE, mais le sera apparemment lorsque Spartan arrivera.

(Merci au commentaire de Point-virgule et à la réponse d' urish pour l'avoir signalé.)

Réponse originale:

Non, il n'y a pas d'équivalent pour les nombres binaires. JavaScript ne prend en charge que les littéraux numériques aux formats décimal (sans préfixe), hexadécimal (préfixe 0x) et octal (préfixe 0).

Une alternative possible est de passer une chaîne binaire à la parseIntméthode avec la base:

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

Dans ECMASCript 6, cela sera pris en charge en tant que partie du langage, c'est 0b1111 === 15-à- dire vrai. Vous pouvez également utiliser un B majuscule (par exemple 0B1111).

Recherchez NumericLiteralsdans la spécification ES6 .

Je sais que les gens disent que l'extension des prototypes n'est pas une bonne idée, mais c'était votre scénario ...

Je le fais de cette façon:

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

Si votre principale préoccupation est l'affichage plutôt que le codage, il existe un système de conversion intégré que vous pouvez utiliser:

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

Réf: Référence du numéro JavaScript

Autant que je sache, il n'est pas possible d'utiliser un dénoteur binaire en Javascript. J'ai trois solutions pour vous, qui ont toutes leurs problèmes. Je pense que l'alternative 3 est la plus «belle» pour la lisibilité, et elle est probablement beaucoup plus rapide que les autres - à l'exception de son coût d'exécution initial. Le problème est qu'il ne prend en charge que les valeurs jusqu'à 255.

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

Cette version vous permet de taper soit 8 chiffres binaires b00000000, 4 chiffres b0000et chiffres variables b0. C'est b01illégal, vous devez utiliser b0001ou 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;

Cela peut être utile:

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

Non, mais vous pouvez utiliser parseInt et éventuellement omettre les guillemets.

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

Le seul inconvénient de l'omission des guillemets est que, pour de très grands nombres, vous déborderez plus rapidement:

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

Convertissez des chaînes binaires en nombres et vice-versa.

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

Je sais que cela ne répond pas réellement au Q demandé (qui a déjà été répondu à plusieurs reprises) tel quel, mais je suggère que vous (ou les autres personnes intéressées par ce sujet) considérez le fait que le plus lisible et en arrière / futur / compatible avec les navigateurs serait d'utiliser simplement la représentation hexadécimale.

D'après la formulation du Q, il semblerait que vous ne parliez que d'utiliser des littéraux binaires dans votre code et non de traiter des représentations binaires de valeurs numériques (pour lesquelles parstInt est la voie à suivre).

Je doute que de nombreux programmeurs aient besoin de gérer des nombres binaires qui ne sont pas familiers avec le mappage de 0-F à 0000-1111. faites donc essentiellement des groupes de quatre et utilisez la notation hexadécimale.

donc au lieu d'écrire 101000000010, vous utiliseriez 0xA02 qui a exactement la même signification et est beaucoup plus lisible et moins susceptible d'avoir des erreurs.

Considérez simplement la lisibilité, essayez de comparer lequel de ceux-ci est le plus grand:
10001000000010010 ou 1001000000010010

et si je les écris comme ceci:
0x11012 ou 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; }
}