Calculatrice binaire (opérations bit à bit), gratuite

Comment ça marche

1. Saisissez deux nombres : entrez les valeurs sur lesquelles opérer, en décimal, binaire (préfixe 0b) ou hexadécimal (préfixe 0x).
2. Choisissez l'opération : sélectionnez AND, OR, XOR, NOT, décalage gauche (<<) ou décalage droit (>>).
3. Consultez le résultat : la sortie affiche le résultat en décimal, binaire et hexadécimal en même temps, avec une visualisation bit à bit.

Pourquoi utiliser la calculatrice binaire ?

Les opérations bit à bit sont fondamentales en programmation système, cryptographie, développement de jeux, graphismes, réseau et systèmes embarqués. Comprendre comment AND, OR, XOR et les décalages manipulent les bits individuels est crucial pour activer/désactiver des drapeaux, compacter des données et implémenter des algorithmes efficaces. Cette calculatrice montre l'opération au niveau du bit pour voir exactement comment chaque bit est affecté.

Fonctionnalités

• Tous les opérateurs bit à bit : AND (&), OR (|), XOR (^), NOT (~), décalage gauche (<<) et décalage droit (>>).
• Entrée multi-bases : saisissez des nombres en décimal, binaire (0b…) ou hexadécimal (0x…).
• Sortie multi-bases : les résultats sont affichés simultanément en décimal, binaire et hexadécimal.
• Visualisation des bits : une grille visuelle montre quels bits sont activés pour chaque opérande et pour le résultat.
• Modes signé/non signé : basculez entre entiers 8, 16, 32 et 64 bits.

Questions fréquentes

À quoi sert XOR en programmation ?

XOR (^) sert à inverser des bits, faire du chiffrement/obfuscation simple, échanger des variables sans variable temporaire, vérifier la parité et mélanger des hachages. Il renvoie 1 quand les bits diffèrent et 0 quand ils sont identiques.

Quelle est la différence entre << et >> ?

Le décalage gauche (<<) déplace tous les bits vers la gauche, équivalent à une multiplication par des puissances de 2. Le décalage droit (>>) déplace les bits vers la droite, équivalent à une division par des puissances de 2. Le décalage droit arithmétique préserve le bit de signe ; le décalage droit logique remplit avec des zéros.

Comment activer ou désactiver un bit précis ?

Pour activer le bit n : value |= (1 << n). Pour désactiver le bit n : value &= ~(1 << n). Pour inverser le bit n : value ^= (1 << n). Pour vérifier si le bit n est activé : (value & (1 << n)) !== 0.

De l'algèbre booléenne au silicium : comment les opérations bit-à-bit sont devenues universelles

Les opérations bit-à-bit que chaque CPU moderne implémente proviennent de deux articles fondateurs publiés à plus de 80 ans d'intervalle. En 1854, George Boole a publié «An Investigation of the Laws of Thought», définissant l'algèbre de la logique à deux valeurs, AND, OR, NOT, et leurs identités. C'était un travail philosophique, pas d'ingénierie. Puis en 1937, un étudiant de master du MIT âgé de 21 ans nommé Claude Shannon a écrit sa thèse de master «A Symbolic Analysis of Relay and Switching Circuits», prouvant que l'algèbre booléenne pouvait décrire les circuits à relais électriques et donc que tout calcul logique pouvait être physiquement implémenté. Cette thèse est largement citée comme la thèse de master la plus importante du 20e siècle et est le fondement de toute l'électronique numérique. Le complément à deux, la représentation binaire pour les nombres négatifs que chaque CPU utilise, a été breveté en 1962 par Burroughs Corporation mais avait été utilisé dans l'IBM 704 (1954) et d'autres premières machines. IEEE 754 a standardisé la représentation à virgule flottante en 1985, fixant la disposition des bits que chaque Number JavaScript utilise encore, 1 bit de signe, 11 exposant, 52 mantisse pour binary64. Aujourd'hui, les opérateurs du langage C & | ^ ~ << >> se mappent presque directement à des instructions CPU uniques, ce qui explique pourquoi le code bit-à-bit peut être dramatiquement plus rapide que l'équivalent arithmétique.

Les six opérateurs, ce qu'ils font au niveau du bit

• AND (&). Le bit résultat est 1 seulement si les deux bits d'entrée sont 1. 0b1100 & 0b1010 = 0b1000. Utilisez pour masquer, isoler des bits spécifiques, ou vérifier si un drapeau est activé : flags & FLAG_READ est non-zéro ssi FLAG_READ est activé.
• OR (|). Le bit résultat est 1 si l'un des bits d'entrée est 1. 0b1100 | 0b1010 = 0b1110. Utilisez pour définir des bits, combiner des drapeaux : flags = FLAG_READ | FLAG_WRITE.
• XOR (^). Le bit résultat est 1 si exactement un bit d'entrée est 1. 0b1100 ^ 0b1010 = 0b0110. Utilisez pour basculer des bits, obfuscation simple (x ^ x = 0, donc XOR est son propre inverse), parité et mélange de hash.
• NOT (~). Inverser chaque bit. ~0b0000_1111 = 0b1111_0000 (en 8 bits). En complément à deux, ~x équivaut à -x − 1, donc ~5 === -6 en JavaScript.
• Décalage gauche (<<). Déplacer tous les bits vers la gauche de n positions, remplir la droite avec des zéros. 1 << 3 === 8, équivalent à multiplier par 2³. Utile pour construire des masques de bits : 1 << n est «le bit à la position n».
• Décalage droit (>> arithmétique, >>> logique). Déplacer les bits vers la droite. Le décalage arithmétique (>> en JS, Java, C signé) préserve le bit de signe ; le décalage logique (>>> en JS, >> en C non signé) remplit avec des zéros. -8 >> 1 === -4 mais -8 >>> 1 === 2147483644 en JavaScript parce que >>> convertit d'abord en int non signé 32 bits.

Où le bit-à-bit gagne réellement sa place

• Drapeaux de bits et bascules de fonctionnalités. Empaqueter 32 options booléennes dans un seul entier. Les permissions de fichiers Linux (chmod 755), les en-têtes de protocoles réseau (TCP, IPv4), et les drapeaux d'état OpenGL utilisent tous ce modèle. Une vérification & vous indique si une fonctionnalité est activée.
• Permissions de fichiers Unix. rwxr-xr-x est 0b111_101_101 = 0o755 = 493. Les trois groupes sont utilisateur/groupe/autre, chaque trois bits sont read/write/execute. La calculatrice chmod transforme la forme symbolique en l'entier que votre shell veut.
• Masques de sous-réseau IP. Un masque /24 est 255.255.255.0 ou 0xFFFFFF00. Pour vérifier si une IP est dans un sous-réseau : (ip & mask) === (network & mask). Utilisé par chaque routeur et pare-feu du monde.
• Cryptographie et hachage. SHA-256, AES, ChaCha20, BLAKE3, chaque hash et chiffrement moderne est construit principalement à partir d'AND, OR, XOR, NOT et rotations. XOR seul est la base des masques à usage unique, qui sont prouvés inviolables quand la clé est vraiment aléatoire et utilisée une fois.
• Manipulation des couleurs. Une couleur RGBA 32 bits empaquette quatre canaux 8 bits : (R << 24) | (G << 16) | (B << 8) | A. Pour extraire le canal rouge : (color >> 24) & 0xFF. Utilisé par HTML canvas, OpenGL, chaque format d'image.
• Astuces de performance. x & 1 est beaucoup plus rapide que x % 2 sur la plupart des CPU (un cycle vs ~10). x >> 1 divise par 2 en un cycle. L'alignement à la puissance de deux, les comptes de population de bits, et les hacks de manipulation de bits sont partout dans le code critique en performance. (Voir la page «Bit Twiddling Hacks» de Sean Anderson pour un catalogue célèbre.)
• Systèmes embarqués. Les microcontrôleurs mappent les registres matériels à des positions de bits spécifiques en mémoire. Configurer un UART ou une broche GPIO nécessite de masquer et décaler pour lire ou écrire les bons bits sans perturber le reste. La syntaxe de bitfield de C est un sucre commode pour ces modèles.

Erreurs qui mordent

• Confondre & avec && et | avec ||. Les formes simples sont bit-à-bit, les doubles sont logiques court-circuit. 1 & 2 === 0 (pas de bits partagés) mais 1 && 2 === 2 (les deux véridiques, retourne le second). Les confondre casse silencieusement la logique conditionnelle.
• Surprises de précédence des opérateurs. x & FLAG === 0 signifie x & (FLAG === 0), pas (x & FLAG) === 0, parce que === se lie plus étroitement que &. Toujours parenthéser les expressions bit-à-bit dans les conditions.
• Confusion décalage signé vs non signé. En JavaScript, >> est arithmétique (extension de signe), >>> est logique (remplissage zéro). C distingue par le type de variable, les types signés utilisent arithmétique, les non signés utilisent logique. Java a à la fois >> et >>> comme JavaScript. Mal correspondre à la convention du langage inverse silencieusement le sens.
• JavaScript tronque à 32 bits pour les opérations bit-à-bit. Bien que Number soit un flottant 64 bits, tous les opérateurs bit-à-bit convertissent les opérandes en int32 d'abord. 0x100000000 & 0xFF === 0, pas 0 + l'octet bas, parce que l'opérande est tronqué à 32 bits avant le AND. Pour la manipulation de bits 64 bits, utilisez BigInt, qui a ses propres opérateurs bit-à-bit.
• Décaler par > 31 en JavaScript. 1 << 32 === 1, pas 0. La quantité de décalage est prise modulo 32. C est encore plus dangereux : décaler de plus que la largeur de bit est un comportement indéfini, donc les compilateurs peuvent faire n'importe quoi. Toujours vérifier n < bitWidth avant de décaler par une valeur d'exécution.
• Endianness dans le code d'empaquetage d'octets. (r << 24) | (g << 16) | (b << 8) | a produit 0xRRGGBBAA. Que les octets soient stockés dans cet ordre ou inversés en mémoire dépend de la plateforme. ImageData dans HTML canvas est little-endian sur x86 ; le format de fichier PNG est big-endian. Convertir explicitement avec DataView en lisant des formats binaires.
• Oublier le complément à deux. ~0 === -1, pas 0xFFFFFFFF, parce que tout-uns est l'encodage en complément à deux de −1. Pour obtenir l'interprétation 32 bits non signée en JavaScript : (~0) >>> 0 === 4294967295.

Pourquoi le complément à deux, et ce qu'il signifie au niveau du bit

Chaque CPU moderne représente les entiers négatifs en utilisant le complément à deux. Dans un octet signé 8 bits, les valeurs 0 à 127 sont encodées comme binaire 0000_0000 à 0111_1111. Puis −1 est encodé comme 1111_1111, −2 comme 1111_1110, jusqu'à −128 comme 1000_0000. La raison : avec cet encodage, l'addition fonctionne de la même façon que les entrées soient signées ou non signées, le CPU n'a pas besoin d'instructions add-signé et add-non-signé séparées. L'asymétrie est que la plage négative est plus grande que la positive (en 8 bits, −128 à +127), c'est pourquoi Math.abs(INT_MIN) déborde dans chaque langage avec des entiers à largeur fixe. Les encodages plus anciens signe-magnitude (un bit pour le signe, le reste pour la magnitude) et complément à un existaient dans les années 1950-60 mais ont perdu face au complément à deux parce qu'ils avaient deux représentations de zéro et nécessitaient du matériel cas-spécial pour la négation.

Plus de questions fréquentes

Pourquoi ~5 est-il égal à -6 au lieu de 250 ?

Parce qu'en complément à deux (l'encodage que chaque CPU moderne utilise), inverser chaque bit d'un nombre positif donne -n - 1. Donc ~5 === -6 et ~0 === -1. Dans un contexte non signé 8 bits, le même motif de bits que ~5 (binaire 1111_1010) représenterait 250. JavaScript traite le résultat comme signé 32 bits, donc vous voyez -6. Pour obtenir l'interprétation non signée : (~5) >>> 0 en 32 bits, ce qui donne 4294967290, ou masquer à 8 bits avec ~5 & 0xFF qui donne 250.

Est-ce que XOR est vraiment un chiffrement ?

XOR est le bloc de construction de chaque chiffrement symétrique moderne, mais XOR seul n'est pas un chiffrement sécurisé. Un masque à usage unique, XOR avec une clé vraiment aléatoire aussi longue que le message, utilisée exactement une fois, est théoriquement de l'information inviolable (Shannon, 1949). Réutiliser la clé, ou utiliser une clé plus courte que le message, et l'analyse de fréquence le casse trivialement. Les vrais chiffrements comme AES utilisent XOR plus diffusion et substitution pour amplifier une courte clé en un flux d'octets pseudo-aléatoires qui ressemblent à un masque à usage unique pour quiconque sans la clé. Donc «chiffrer avec XOR» est bien seulement pour l'obfuscation triviale, jamais pour de vrais secrets.

Quand devrais-je utiliser BigInt au lieu de Number pour la manipulation de bits ?

Chaque fois que vous avez besoin de plus de 32 bits de précision bit-à-bit. Les opérateurs bit-à-bit JavaScript tronquent les opérandes Number à des entiers signés 32 bits avant le calcul. Si vous avez besoin de masques 64 bits (par ex. manipulation d'un ensemble de drapeaux de fonctionnalités 64 bits, travail avec les offsets mmap Linux, ou implémentation de SHA-512), utilisez BigInt : 0xFFFFFFFFFFFFFFFFn & 0xFFn === 255n. BigInt est plus lent que Number, ~3-10× selon l'opération, donc réservez-le pour les cas où 32 bits sont véritablement insuffisants.

Comment puis-je compter le nombre de bits 1 dans un nombre ?

C'est le compte de population ou poids de Hamming. La plupart des CPU modernes ont une seule instruction pour cela (POPCNT sur x86, VCNT sur ARM). En JavaScript, pas de natif, alors utilisez le classique de manipulation de bits : let c = 0; while (x) { c += x & 1; x >>>= 1; }. Ou l'astuce SWAR parallèle de Hacker's Delight : x = x - ((x >> 1) & 0x55555555); x = (x & 0x33333333) + ((x >> 2) & 0x33333333); x = (x + (x >> 4)) & 0x0F0F0F0F; return (x * 0x01010101) >>> 24;, qui compte les bits dans un entier 32 bits en environ une douzaine de cycles.

Mes données sont-elles envoyées quelque part quand j'utilise cette calculatrice ?

Non. Chaque opération s'exécute dans le moteur JavaScript de votre navigateur, aucun appel réseau ne se produit pendant un calcul. Ouvrez l'onglet Réseau dans DevTools et cliquez Calculer, vous verrez zéro requête sortante. Sûr pour les masques sensibles, les clés ou le travail de mise en page de bits propriétaire.