Comment convertir un entier en binaire en JavaScript?

Le binaire dans 'convertir en binaire" peut désigner trois choses principales. Le système de nombre de position, la représentation binaire en mémoire ou les cordons de bits 32bit. (pour 64 bits voir réponse de Patrick Roberts )

1. Système De Numérotation

(123456).toString(2) convertira les nombres en base 2 système numérique de position . Dans ce système, les nombres négatifs sont écrits avec moins des signes comme en décimal.

2. Représentation Interne

La représentation interne des nombres est 64 bits à virgule flottante et certaines limites sont discutées dans cette réponse . Il y a no easy way pour créer une représentation en chaîne de bits dans javascript ou accéder à des bits spécifiques.

3. Masques Et Bit-À-Bit Opérateurs

MDN a un bon aperçu de la façon dont les opérateurs bitwise travailler. Important:

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

avant l'application des opérations les nombres à points flottants de 64 bits sont lancés sur des entiers signés de 32 bits. Après ils sont reconvertis.

Voici le code D'exemple 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"

une manière simple est juste...

Number(42).toString(2);

// "101010"

Note-le (x>>>0).toString(2); de base présente un léger problème lorsque x est positif. J'ai un exemple de code à la fin de ma réponse qui résout ce problème avec le >>> méthode tout en utilisant >>>.

(-3>>>0).toString(2);

prints -3 in 2s complement.

1111111111101

exemple pratique

C:\>type n1.js
console.log(   (-3 >>> 0).toString(2)    );
C:\>
C:\>node n1.js
11111111111111111111111111111101

C:\>

ceci dans la barre D'URL est une autre preuve rapide

javascript:alert((-3>>>0).toString(2))

Note-le résultat est très légèrement défectueux, en ce qu'il commence toujours par un 1, qui pour les nombres négatifs est fin. Pour les nombres positifs, vous devez préparer un 0 Au début pour que le résultat soit vraiment un complément 2s. Donc (8>>>0).toString(2) produit 1000 qui n'est pas vraiment 8 en complément 2s, mais en préparant ce 0, ce qui fait 01000, est correct 8 en complément 2s. Dans le complément 2S approprié, toute chaîne de bits commençant par 0 est >=0, et toute chaîne de bits commençant par 1 est négative.

, par exemple, cette contourne le problème

// or x=-5  whatever number you want to view in binary  
x=5;   
if(x>0) prepend="0"; else prepend=""; 
alert(prepend+((x>>>0)).toString(2));

les autres solutions sont les suivantes: un de Annan (bien que les explications et les définitions DE Annan sont pleines d'erreurs, il a le code qui produit la bonne sortie), et la solution de Patrick.

N'importe qui qui ne comprend pas le fait des nombres positifs commençant par 0 et des nombres négatifs avec 1, dans le complément 2s, pourrait vérifier cela ainsi QnA sur le complément 2s. Qu'est-ce que"le complément de 2"?

Vous pouvez écrire votre propre fonction qui retourne un tableau de bits. Exemple comment convertir 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 so 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.

C'est mon code:

var x = prompt("enter number", "7");
var i = 0;
var binaryvar = " ";

function add(n) {
    if (n == 0) {
        binaryvar = "0" + binaryvar; 
    }
    else {
        binaryvar = "1" + binaryvar;
    }
}

function binary() {
    while (i < 1) {
        if (x == 1) {
            add(1);
            document.write(binaryvar);
            break;
        }
        else {
            if (x % 2 == 0) {
                x = x / 2;
                add(0);
            }
            else {
                x = (x - 1) / 2;
                add(1);
            }
        }
    }
}

binary();

C'est la solution . C'est assez simple comme une question de fait

function binaries(num1){ 
        var str = num1.toString(2)
        return(console.log('The binary form of ' + num1 + ' is: ' + str))
     }
     binaries(3

)

        /*
         According to MDN, Number.prototype.toString() overrides 
         Object.prototype.toString() with the useful distinction that you can 
         pass in a single integer argument. This argument is an optional radix, 
         numbers 2 to 36 allowed.So in the example above, we’re passing in 2 to 
         get a string representation of the binary for the base 10 number 100, 
         i.e. 1100100.
        */