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

function dec2bin(dec) {
  return (dec >>> 0).toString(2);
}

console.log(dec2bin(1)); // 1
console.log(dec2bin(-1)); // 11111111111111111111111111111111
console.log(dec2bin(256)); // 100000000
console.log(dec2bin(-256)); // 11111111111111111111111100000000

Vous pouvez utiliser Number.toString(2) mais elle pose quelques problèmes lorsqu'elle représente des nombres négatifs. Par exemple, (-1).toString(2) Le résultat est "-1" .

Pour résoudre ce problème, vous pouvez utiliser l'opérateur bitwise de décalage à droite non signé ( >>> ) pour forcer votre nombre à devenir un entier non signé.

Si vous exécutez (-1 >>> 0).toString(2) vous décalez votre nombre de 0 bits vers la droite, ce qui ne change pas le nombre lui-même, mais il sera représenté comme un entier non signé. Le code ci-dessus donnera "11111111111111111111111111111111" correctement.

Cette question fournit de plus amples explications.

-3 >>> 0 (décalage logique à droite) transforme ses arguments en entiers non signés, ce qui explique la représentation de -3 en complément à deux sur 32 bits.

Answer 2

Essayer

num.toString(2);

Le 2 est le radix et peut être n'importe quelle base entre 2 et 36.

source ici

UPDATE :

Cela ne fonctionne que pour les nombres positifs, Javascript représente les nombres entiers binaires négatifs en notation à deux compléments. J'ai créé cette petite fonction qui devrait faire l'affaire, mais je ne l'ai pas encore testée correctement :

function dec2Bin(dec)
{
    if(dec >= 0) {
        return dec.toString(2);
    }
    else {
        /* Here you could represent the number in 2s compliment but this is not what 
           JS uses as its not sure how many bits are in your number range. There are 
           some suggestions https://stackoverflow.com/questions/10936600/javascript-decimal-to-binary-64-bit 
        */
        return (~dec).toString(2);
    }
}

J'ai reçu l'aide de ici

Answer 3

Un moyen simple consiste à...

Number(42).toString(2);

// "101010"

Answer 4

Le terme "binaire" dans l'expression "convertir en binaire" peut se référer à trois choses principales. Le système des nombres positionnels, la représentation binaire en mémoire ou les chaînes de bits de 32 bits. (pour les chaînes de bits de 64 bits, voir Réponse de Patrick Roberts )

1. Le système des nombres

(123456).toString(2) convertira les nombres en base 2 système de numération positionnelle . Dans ce système, les nombres négatifs s'écrivent avec le signe moins, comme dans le système décimal.

2. Représentation interne

La représentation interne des nombres est 64 bits à virgule flottante et certaines limitations sont discutées dans cette réponse . Il y a pas de solution de facilité pour créer une représentation sous forme de chaîne de bits en javascript et accéder à des bits spécifiques.

3. Masques et opérateurs bitwise

MDN dispose d'une bonne vue d'ensemble sur le fonctionnement des opérateurs bitwise. Il est important de noter que

Les opérateurs bitwise traitent leurs opérandes comme une séquence de 32 bits (zéros et uns)

Avant que les opérations ne soient appliquées, les nombres à virgule flottante de 64 bits sont convertis en nombres entiers signés de 32 bits. Ils sont ensuite reconvertis.

Voici l'exemple de code MDN pour convertir des nombres en chaînes de 32 bits.

function createBinaryString (nMask) {
  // nMask must be between -2147483648 and 2147483647
  for (var nFlag = 0, nShifted = nMask, sMask = ""; nFlag < 32;
       nFlag++, sMask += String(nShifted >>> 31), nShifted <<= 1);
  return sMask;
}

createBinaryString(0) //-> "00000000000000000000000000000000"
createBinaryString(123) //-> "00000000000000000000000001111011"
createBinaryString(-1) //-> "11111111111111111111111111111111"
createBinaryString(-1123456) //-> "11111111111011101101101110000000"
createBinaryString(0x7fffffff) //-> "01111111111111111111111111111111"

Answer 5

Cette réponse tente de traiter les entrées dont la valeur absolue se situe dans la plage 2147483648 ₁₀ (2 31 ) - 9007199254740991 ₁₀ (2 53 -1).

---

En JavaScript, les nombres sont stockés dans Représentation en virgule flottante de 64 bits mais les opérations par bit les convertissent en nombres entiers de 32 bits en format complément à deux Par conséquent, toute approche utilisant des opérations par bit limite la plage de sortie à -2147483648. ₁₀ (-2 31 ) - 2147483647 ₁₀ (2 31 -1).

Toutefois, si l'on évite les opérations par bit et que l'on préserve la représentation en virgule flottante de 64 bits en utilisant uniquement des opérations mathématiques, on peut convertir de manière fiable n'importe quelle nombre entier sûr en notation binaire à deux compléments de 64 bits en étendant le signe de la notation binaire de 53 bits. twosComplement :

function toBinary (value) {
  if (!Number.isSafeInteger(value)) {
    throw new TypeError('value must be a safe integer');
  }

  const negative = value < 0;
  const twosComplement = negative ? Number.MAX_SAFE_INTEGER + value + 1 : value;
  const signExtend = negative ? '1' : '0';

  return twosComplement.toString(2).padStart(53, '0').padStart(64, signExtend);
}

function format (value) {
  console.log(value.toString().padStart(64));
  console.log(value.toString(2).padStart(64));
  console.log(toBinary(value));
}

format(8);
format(-8);
format(2**33-1);
format(-(2**33-1));
format(2**53-1);
format(-(2**53-1));
format(2**52);
format(-(2**52));
format(2**52+1);
format(-(2**52+1));

.as-console-wrapper{max-height:100%!important}

Pour les navigateurs plus anciens, il existe des polyfills pour les fonctions et valeurs suivantes :

• Number.isSafeInteger()
• Number.isInteger()
• Number.MAX_SAFE_INTEGER
• String.prototype.padStart()

En outre, vous pouvez prendre en charge n'importe quel radix (2-36) si vous effectuez la conversion en complément à deux pour les nombres négatifs dans 64 / log ₂ (radix) en utilisant BigInt :

function toRadix (value, radix) {
  if (!Number.isSafeInteger(value)) {
    throw new TypeError('value must be a safe integer');
  }

  const digits = Math.ceil(64 / Math.log2(radix));
  const twosComplement = value < 0
    ? BigInt(radix) ** BigInt(digits) + BigInt(value)
    : value;

  return twosComplement.toString(radix).padStart(digits, '0');
}

console.log(toRadix(0xcba9876543210, 2));
console.log(toRadix(-0xcba9876543210, 2));
console.log(toRadix(0xcba9876543210, 16));
console.log(toRadix(-0xcba9876543210, 16));
console.log(toRadix(0x1032547698bac, 2));
console.log(toRadix(-0x1032547698bac, 2));
console.log(toRadix(0x1032547698bac, 16));
console.log(toRadix(-0x1032547698bac, 16));

.as-console-wrapper{max-height:100%!important}

Si vous êtes intéressé par mon ancienne réponse qui utilisait un ArrayBuffer pour créer une union entre un Float64Array et un Uint16Array , veuillez vous référer à la réponse historique des révisions .