J'aimerais voir des entiers, positifs ou négatifs, en binaire.
Plutôt comme cette question , mais pour JavaScript.
J'aimerais voir des entiers, positifs ou négatifs, en binaire.
Plutôt comme cette question , mais pour JavaScript.
Réponses:
function dec2bin(dec){
return (dec >>> 0).toString(2);
}
dec2bin(1); // 1
dec2bin(-1); // 11111111111111111111111111111111
dec2bin(256); // 100000000
dec2bin(-256); // 11111111111111111111111100000000
Vous pouvez utiliser la Number.toString(2)
fonction, mais elle a quelques problèmes lors de la représentation des nombres négatifs. Par exemple, la (-1).toString(2)
sortie est "-1"
.
Pour résoudre ce problème, vous pouvez utiliser l'opérateur au niveau du bit de décalage à droite non signé ( >>>
) pour contraindre votre numéro à un entier non signé.
Si vous exécutez, (-1 >>> 0).toString(2)
vous décalerez 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 sortira "11111111111111111111111111111111"
correctement.
Cette question a une explication supplémentaire.
-3 >>> 0
(décalage logique vers la droite) contraint ses arguments à des entiers non signés, c'est pourquoi vous obtenez la représentation du complément à 32 bits de -3.
Essayer
num.toString(2);
Le 2 est le radix et peut être n'importe quelle base entre 2 et 36
source ici
METTRE À JOUR:
Cela ne fonctionnera que pour les nombres positifs, Javascript représente des entiers binaires négatifs en notation à complément à deux. J'ai fait cette petite fonction qui devrait faire l'affaire, je ne l'ai pas 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 /programming/10936600/javascript-decimal-to-binary-64-bit
*/
return (~dec).toString(2);
}
}
J'ai eu de l'aide d' ici
-3
retours 1
). Je pense aussi que cela dec > 0
devrait être dec >= 0
, ce qui devrait au moins fixer 0. Parce que les dec2Bin(0)
retours 10
.
Le binaire dans 'convertir en binaire' peut se référer à trois choses principales. Le système de nombres positionnels, la représentation binaire en mémoire ou les chaînes de bits 32 bits. (pour les chaînes de bits 64 bits, voir la réponse de Patrick Roberts )
1. Système de numérotation
(123456).toString(2)
convertira les nombres en système de chiffres positionnels de base 2 . Dans ce système, les nombres négatifs sont écrits avec des signes négatifs comme en décimal.
2. Représentation interne
La représentation interne des nombres est une virgule flottante de 64 bits et certaines limitations sont discutées dans cette réponse . Il n'y a pas de moyen facile de créer une représentation de chaîne de bits de cela en javascript ni d'accéder à des bits spécifiques.
3. Masques et opérateurs au niveau du bit
MDN a une bonne vue d' ensemble du fonctionnement des opérateurs au niveau du bit. Surtout:
Les opérateurs au niveau du bit traitent leurs opérandes comme une séquence de 32 bits (zéros et uns)
Avant d'appliquer les opérations, les nombres à virgule flottante 64 bits sont convertis en entiers signés 32 bits. Une fois qu'ils sont reconvertis.
Voici l'exemple de code MDN pour convertir des nombres en chaînes 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"
Un moyen simple est juste ...
Number(42).toString(2);
// "101010"
(42).toString(2)
42..toString(2)
1.
ce qui est identique 1.0
ou juste 1
(et de même, vous pouvez également omettre la partie avant et écrire à la .5
place de 0.5
). Ainsi, dans l'exemple, le premier point est le séparateur décimal qui fait partie du nombre et le deuxième point est l'opérateur de point pour appeler la méthode sur ce nombre. Vous devez utiliser deux points (ou encapsuler le nombre entre parenthèses) et ne pouvez pas simplement écrire 42.toString(2)
car l'analyseur voit le point comme séparateur décimal et renvoie une erreur en raison d'un opérateur de point manquant.
Cette réponse tente d'adresser les entrées avec une valeur absolue dans la plage de 2147483648 10 (2 31 ) - 9007199254740991 10 (2 53 -1).
En JavaScript, les nombres sont stockés dans une représentation en virgule flottante 64 bits , mais les opérations au niveau du bit les contraignent à des entiers 32 bits au format complément à deux , de sorte que toute approche qui utilise des opérations au niveau du bit limite la plage de sortie à -2147483648 10 (-2 31 ) - 2147483647 10 (2 31 -1).
Cependant, si les opérations au niveau du bit sont évitées et que la représentation en virgule flottante 64 bits est préservée en utilisant uniquement des opérations mathématiques, nous pouvons convertir de manière fiable tout entier sûr en notation binaire complémentaire à deux bits 64 bits en étendant les 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, des polyfills existent pour les fonctions et valeurs suivantes:
En prime, vous pouvez prendre en charge n'importe quel radix (2–36) si vous effectuez la conversion du complément à deux pour les nombres négatifs en chiffres ⌈64 / log 2 (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 an ArrayBuffer
pour créer une union entre a Float64Array
et a Uint16Array
, veuillez vous référer à l' historique de révision de cette réponse .
-(2**53)-1
au 2**53-1
lieu de simplement -(2**31)
à 2**31-1
comme la réponse de annan.
Une solution avec laquelle j'irais bien pour 32 bits, est le code à la fin de cette réponse, qui est de developer.mozilla.org (MDN), mais avec quelques lignes ajoutées pour A) le formatage et B) en vérifiant que le le nombre est dans la plage.
Certains ont suggéré x.toString(2)
que cela ne fonctionne pas pour les négatifs, il colle simplement un signe moins pour eux, ce qui n'est pas bon.
Fernando a mentionné une solution simple (x>>>0).toString(2);
qui convient aux négatifs, mais a un léger problème lorsque x est positif. Il a la sortie commençant par 1, ce qui pour les nombres positifs n'est pas le bon complément à 2.
Quiconque ne comprend pas le fait de nombres positifs commençant par 0 et de nombres négatifs avec 1, en complément 2s, pourrait vérifier ce SO QnA sur complément 2s. Qu'est-ce que le «complément 2»?
Une solution pourrait consister à ajouter un 0 pour les nombres positifs, ce que j'ai fait dans une révision précédente de cette réponse. Et on pourrait accepter d'avoir parfois un nombre 33 bits, ou on pourrait s'assurer que le nombre à convertir est dans la plage - (2 ^ 31) <= x <2 ^ 31-1. Le nombre est donc toujours de 32 bits. Mais plutôt que de le faire, vous pouvez opter pour cette solution sur mozilla.org
La réponse et le code de Patrick sont longs et fonctionnent apparemment pour 64 bits, mais il y avait un bogue trouvé par un commentateur et le commentateur a corrigé le bogue de patrick, mais patrick a un "numéro magique" dans son code qu'il n'a pas commenté et a oublié et patrick ne comprend plus pleinement son propre code / pourquoi il fonctionne.
Annan avait une terminologie incorrecte et peu claire mais a mentionné une solution par developer.mozilla.org https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators Cela fonctionne pour les nombres 32 bits.
Le code est assez compact, une fonction de trois lignes.
Mais j'ai ajouté une expression régulière pour formater la sortie en groupes de 8 bits. Basé sur Comment imprimer un nombre avec des virgules en tant que milliers de séparateurs en JavaScript (je viens de le modifier en le regroupant en 3 secondes de droite à gauche et en ajoutant des virgules , en le regroupant en 8 secondes de droite à gauche et en ajoutant des espaces )
Et, alors que mozilla a fait un commentaire sur la taille de nMask (le nombre introduit) ... qu'il doit être dans la plage, ils n'ont pas testé ou jeté une erreur lorsque le nombre est hors plage, donc j'ai ajouté cela.
Je ne sais pas pourquoi ils ont nommé leur paramètre 'nMask' mais je laisserai cela tel quel.
Référence: 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"
Vous pouvez écrire votre propre fonction qui renvoie un tableau de bits. Exemple comment convertir un nombre en bits
exemple de 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
}
Lisez les restes de bas en haut. Chiffre 1 du milieu vers le haut.
Math.floor(number%2)
lieu de number = Math.floor(number/2)
?
J'ai utilisé une approche différente pour trouver quelque chose qui fait cela. J'ai décidé de ne pas utiliser ce code dans mon projet, mais j'ai pensé le laisser dans un endroit pertinent au cas où il serait utile pour quelqu'un.
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("---");
Encore une 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));
Voici 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();
Voilà la solution. C'est assez simple en 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.
*/