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 que je choisirais et qui convient pour 32 bits est le code à la fin de cette réponse, qui provient de developer.mozilla.org(MDN), mais avec quelques lignes ajoutées pour A) le formatage et B) la vérification que le nombre est dans l'intervalle.

Certains ont suggéré x.toString(2) qui ne fonctionne pas pour les négatifs, il leur colle un signe moins, ce qui n'est pas bon.

Fernando a mentionné une solution simple de (x>>>0).toString(2); ce qui convient pour les négatifs, mais pose un léger problème lorsque x est positif. La sortie commence par 1, ce qui, pour les nombres positifs, n'est pas un complément à 2 correct.

Quiconque ne comprend pas le fait que les nombres positifs commencent par 0 et les nombres négatifs par 1, en complément à 2, peut consulter ce QnA SO sur le complément à 2. Qu'est-ce que le "complément à 2" ?

Une solution pourrait consister à faire précéder les nombres positifs d'un 0, ce que j'ai fait dans une précédente révision de cette réponse. Et on pourrait accepter d'avoir parfois un nombre de 33 bits, ou on pourrait s'assurer que le nombre à convertir est compris dans l'intervalle -(2^31)<=x<2^31-1. Ainsi, le nombre est toujours de 32 bits. Mais plutôt que de faire cela, vous pouvez opter pour cette solution sur mozilla.org

La réponse et le code de Patrick sont longs et fonctionnent apparemment pour le 64-bit, mais il y avait un bug qu'un commentateur a trouvé, et le commentateur a corrigé le bug de patrick, mais patrick a un certain "nombre magique" dans son code qu'il n'a pas commenté et qu'il a oublié, et patrick ne comprend plus complètement son propre code / pourquoi il fonctionne.

M. Annan a utilisé une terminologie incorrecte et peu claire, mais il a mentionné une solution proposée par developer.mozilla.org.

Note : l'ancien lien https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators est maintenant redirigé ailleurs et n'a pas ce contenu, mais l'ancien lien, qui apparaît lorsque archive.org récupère les pages, est disponible ici. https://web.archive.org/web/20150315015832/https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators

La solution proposée fonctionne pour les nombres de 32 bits.

Le code est assez compact, une fonction de trois lignes.

Mais j'ai ajouté une regex pour formater la sortie en groupes de 8 bits. Basé sur Comment formater un nombre avec des virgules comme séparateurs de milliers ? (Je l'ai juste modifié après l'avoir regroupé dans la rubrique 3s de droite à gauche et en ajoutant virgules , au regroupement en 8s de droite à gauche, et en ajoutant espaces )

Et, bien que Mozilla ait fait un commentaire sur la taille de nMask (le nombre introduit) qu'il doit être dans l'intervalle, ils n'ont pas testé ou lancé une erreur quand le nombre est hors de l'intervalle, donc j'ai ajouté cela.

Je ne sais pas trop pourquoi ils ont appelé leur paramètre "nMask", mais je le laisserai tel quel.

https://web.archive.org/web/20150315015832/https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators

function createBinaryString(nMask) {
  // nMask must be between -2147483648 and 2147483647
  if (nMask > 2**31-1) 
     throw "number too large. number shouldn't be > 2**31-1"; //added
  if (nMask < -1*(2**31))
     throw "number too far negative, number shouldn't be < -(2**31)" //added
  for (var nFlag = 0, nShifted = nMask, sMask = ''; nFlag < 32;
       nFlag++, sMask += String(nShifted >>> 31), nShifted <<= 1);
  sMask=sMask.replace(/\B(?=(.{8})+(?!.))/g, " ") // added
  return sMask;
}

console.log(createBinaryString(-1))    // "11111111 11111111 11111111 11111111"
console.log(createBinaryString(1024))  // "00000000 00000000 00000100 00000000"
console.log(createBinaryString(-2))    // "11111111 11111111 11111111 11111110"
console.log(createBinaryString(-1024)) // "11111111 11111111 11111100 00000000"

//added further console.log example
console.log(createBinaryString(2**31 -1)) //"01111111 11111111 11111111 11111111"

Answer 2

Vous pouvez écrire votre propre fonction qui renvoie un tableau de bits. Exemple de conversion d'un nombre en bits

Diviseur| Dividende| bits/reste

2 | 9 | 1

2 | 4 | 0

2 | 2 | 0

~ | 1 |~

Exemple de la ligne ci-dessus : 2 * 4 = 8 et le reste est 1 donc 9 = 1 0 0 1

function numToBit(num){
    var number = num
    var result = []
    while(number >= 1 ){
        result.unshift(Math.floor(number%2))
        number = number/2
    }
    return result
}

Lire les restes de bas en haut. Chiffre 1 du milieu vers le haut.

Answer 3

Voici comment je m'en sors :

const decbin = nbr => {
  if(nbr < 0){
     nbr = 0xFFFFFFFF + nbr + 1
  }
  return parseInt(nbr, 10).toString(2)
};

Je l'ai obtenu à partir de ce lien : https://locutus.io/php/math/decbin/

Answer 4

Nous pouvons également calculer le binaire pour des nombres positifs ou négatifs comme ci-dessous :

function toBinary(n){
    let binary = "";
    if (n < 0) {
      n = n >>> 0;
    }
    while(Math.ceil(n/2) > 0){
        binary = n%2 + binary;
        n = Math.floor(n/2);
    }
    return binary;
}

console.log(toBinary(7));
console.log(toBinary(-7));

Answer 5

Vous pouvez utiliser une solution récursive :

function intToBinary(number, res = "") {
  if (number < 1)
    if (res === "") return "0"
      else 
     return res
  else return intToBinary(Math.floor(number / 2), number % 2 + res)
}
console.log(intToBinary(12))
console.log(intToBinary(546))
console.log(intToBinary(0))
console.log(intToBinary(125))

Ne fonctionne qu'avec des nombres positifs.