Comment convertir un entier en binaire en JavaScript ?

Question

J'aimerais voir les nombres entiers, positifs ou négatifs, en binaire.

Plutôt comme cette question mais pour JavaScript.

Answer 1

Une solution réelle dont la logique peut être mise en œuvre par n'importe quel langage de programmation :

Si vous êtes sûr que c'est uniquement positif :

var a = 0;
var n = 12; // your input
var m = 1;
while(n) {
    a = a + n%2*m;
    n = Math.floor(n/2);
    m = m*10;
}

console.log(n, ':', a) // 12 : 1100

S'il peut être négatif ou positif -

(n >>> 0).toString(2)

Answer 2

J'aimerais voir les nombres entiers, positifs ou négatifs, en binaire.

Il s'agit d'une vieille question et je pense qu'il y a de très bonnes solutions ici, mais il n'y a pas d'explication sur l'utilisation de ces solutions intelligentes.

Tout d'abord, nous devons comprendre qu'un nombre peut être positif ou négatif. De plus, JavaScript fournit une fonction MAX_SAFE_INTEGER qui a une valeur de 9007199254740991 . Ce chiffre s'explique par le fait que JavaScript utilise virgule flottante à double précision formatent les nombres comme spécifié dans IEEE 754 et ne peut représenter en toute sécurité que des nombres entiers compris entre -(2^53 - 1) y 2^53 - 1 .

Nous connaissons donc maintenant la plage dans laquelle les nombres sont "sûrs". De plus, JavaScript ES6 dispose de la méthode intégrée Number.isSafeInteger() pour vérifier si un nombre est un entier sûr.

Logiquement, si l'on veut représenter un nombre n En binaire, ce nombre a besoin d'une longueur de 53 bits, mais pour une meilleure présentation, utilisons 7 groupes de 8 bits = 56 bits et remplissons le côté gauche avec 0 o 1 sur la base de son signe en utilisant le padStart fonction.

Ensuite, nous devons gérer les nombres positifs et négatifs : les nombres positifs s'additionneront 0 vers la gauche, tandis que les nombres négatifs ajouteront 1 s. De même, les nombres négatifs devront être représentés par un complément à deux. Nous pouvons facilement y remédier en ajoutant Number.MAX_SAFE_INTEGER + 1 au numéro.

Par exemple, nous voulons représenter -3 comme binaire, supposons que Number.MAX_SAFE_INTEGER est 00000000 11111111 (255) puis Number.MAX_SAFE_INTEGER + 1 sera 00000001 00000000 (256) . Ajoutons maintenant le nombre Number.MAX_SAFE_INTEGER + 1 - 3 ce sera 00000000 11111101 (253) mais comme nous l'avons dit, nous remplirons le côté gauche avec 1 comme ceci 11111111 11111101 (-3) , ce qui représente -3 en binaire.

Un autre algorithme consistera à ajouter 1 au nombre et inverser le signe comme suit -(-3 + 1) = 2 ce sera 00000000 00000010 (2) . Maintenant, nous inversons chaque bit comme suit 11111111 11111101 (-3) nous avons à nouveau une représentation binaire de -3 .

Nous avons ici un extrait fonctionnel de ces algos :

function dec2binA(n) {
    if (!Number.isSafeInteger(n)) throw new TypeError('n value must be a safe integer')
    if (n > 2**31) throw 'number too large. number should not be greater than 2**31'
    if (n < -1*(2**31)) throw 'number too far negative, number should not be lesser than 2**31'

    const bin = n < 0 ? Number.MAX_SAFE_INTEGER + 1 + n : n
    const signBit = n < 0 ? '1' : '0'

    return parseInt(bin, 10).toString(2)
        .padStart(56, signBit)
        .replace(/\B(?=(.{8})+(?!.))/g, ' ')
}

function dec2binB(n) {
    if (!Number.isSafeInteger(n)) throw new TypeError('n value must be a safe integer')
    if (n > 2**31) throw 'number too large. number should not be greater than 2**31'
    if (n < -1*(2**31)) throw 'number too far negative, number should not be lesser than 2**31'

    const bin = n < 0 ?  -(1 + n) : n
    const signBit = n < 0 ? '1' : '0'

    return parseInt(bin, 10).toString(2)
        .replace(/[01]/g, d => +!+d)
        .padStart(56, signBit)
        .replace(/\B(?=(.{8})+(?!.))/g, ' ')
}

const a = -805306368
console.log(a)
console.log('dec2binA:', dec2binA(a))
console.log('dec2binB:', dec2binB(a))

const b = -3
console.log(b)
console.log('dec2binA:', dec2binA(b))
console.log('dec2binB:', dec2binB(b))

Answer 3

Une autre alternative

const decToBin = dec => {
  let bin = '';
  let f = false;

  while (!f) {
    bin = bin + (dec % 2);    
    dec = Math.trunc(dec / 2);  

    if (dec === 0 ) f = true;
  }

  return bin.split("").reverse().join("");
}

console.log(decToBin(0));
console.log(decToBin(1));
console.log(decToBin(2));
console.log(decToBin(3));
console.log(decToBin(4));
console.log(decToBin(5));
console.log(decToBin(6));

Answer 4

J'ai utilisé une approche différente pour parvenir à ce résultat. J'ai décidé de ne pas utiliser ce code dans mon projet, mais j'ai pensé le laisser quelque part au cas où il serait utile à quelqu'un.

• N'utilise pas le décalage de bits ou la contrainte du complément à deux.
• Vous choisissez le nombre de bits qui sortent (il vérifie les valeurs valides de '8', '16', '32', mais je suppose que vous pouvez changer cela).
• Vous choisissez de le traiter comme un entier signé ou non signé.
• Il vérifiera les problèmes de plage en fonction de la combinaison signé/non signé et du nombre de bits, mais vous devrez améliorer la gestion des erreurs.

• Il contient également la version "inverse" de la fonction qui reconvertit les bits en int. Vous en aurez besoin car il n'y a probablement rien d'autre qui puisse interpréter cette sortie :D

  function intToBitString(input, size, unsigned) { if ([8, 16, 32].indexOf(size) == -1) { throw "invalid params"; } var min = unsigned ? 0 : - (2 size / 2); var limit = unsigned ? 2 size : 2 ** size / 2; if (!Number.isInteger(input) || input < min || input >= limit) { throw "out of range or not an int"; } if (!unsigned) { input += limit; } var binary = input.toString(2).replace(/^-/, ''); return binary.padStart(size, '0'); }

  function bitStringToInt(input, size, unsigned) { if ([8, 16, 32].indexOf(size) == -1) { throw "invalid params"; } input = parseInt(input, 2); if (!unsigned) { input -= 2 ** size / 2; } return input; }

  // EXAMPLES

  var res; console.log("(uint8)10"); res = intToBitString(10, 8, true); console.log("intToBitString(res, 8, true)"); console.log(res); console.log("reverse:", bitStringToInt(res, 8, true)); console.log("---");

  console.log("(uint8)127"); res = intToBitString(127, 8, true); console.log("intToBitString(res, 8, true)"); console.log(res); console.log("reverse:", bitStringToInt(res, 8, true)); console.log("---");

  console.log("(int8)127"); res = intToBitString(127, 8, false); console.log("intToBitString(res, 8, false)"); console.log(res); console.log("reverse:", bitStringToInt(res, 8, false)); console.log("---");

  console.log("(int8)-128"); res = intToBitString(-128, 8, false); console.log("intToBitString(res, 8, true)"); console.log(res); console.log("reverse:", bitStringToInt(res, 8, true)); console.log("---");

  console.log("(uint16)5000"); res = intToBitString(5000, 16, true); console.log("intToBitString(res, 16, true)"); console.log(res); console.log("reverse:", bitStringToInt(res, 16, true)); console.log("---");

  console.log("(uint32)5000"); res = intToBitString(5000, 32, true); console.log("intToBitString(res, 32, true)"); console.log(res); console.log("reverse:", bitStringToInt(res, 32, true)); console.log("---");

Answer 5

Voici la méthode que j'utilise. C'est une méthode très rapide et concise qui fonctionne pour les nombres entiers.

Si vous le souhaitez, cette méthode fonctionne également avec les BigInts. Il suffit de modifier chaque 1 a 1n .

// Assuming {num} is a whole number
function toBin(num){
    let str = "";
    do {
        str = `${num & 1}${str}`;
        num >>= 1;
    } while(num);
    return str
}

Explication

Cette méthode passe en quelque sorte par tous les bits du nombre comme s'il s'agissait déjà d'un nombre binaire.

Il commence par une chaîne vide, puis ajoute la dernière partie. num & 1 renvoie le dernier bit du nombre ( 1 o 0 ). num >>= 1 supprime alors le dernier bit et fait de l'avant-dernier bit le nouveau dernier bit. Le processus est répété jusqu'à ce que tous les bits aient été lus.

Bien sûr, il s'agit d'une simplification extrême de ce qui se passe réellement. Mais c'est ainsi que je le généralise.