Calculateur bit à bit

Effectuez AND, OR, XOR, NOT, décalages et rotations sur des valeurs 8/16/32/64 bits avec un calcul bigint exact. Saisissez les opérandes en binaire, octal, décimal ou hex et lisez le résultat dans toutes les bases plus une grille de bits en direct. 100 % dans votre navigateur.

Data & DevOps

cosmodev ~/tools/bitwise

Opération

Opérande A

Opérande B

cosmodev ~/docs/bitwise.md

Ce que ça fait

Le Bitwise Calculator effectue des opérations binaires exactes, masquées sur la largeur, sur des valeurs 8 / 16 / 32 / 64 bits. Entrez les opérandes en binaire, octal, décimal ou hexa - chaque opérande garde sa propre base - et lisez le résultat dans toutes les bases à la fois dans le panneau de résultat épinglé, qui porte des badges pour l’opérateur actif et la largeur (ex. XOR · 8-bit) et une grille de bits en direct soulignant exactement quels bits sont à 1. Opérations prises en charge : AND, OR, XOR, NOT (unaire), SHL/SHR (décalages logiques) et ROL/ROR (rotations qui bouclent dans la largeur choisie). Tous les calculs tournent sur bigint, donc les résultats sont exacts, sans arrondi flottant. Tout reste dans votre navigateur.

Référence des opérateurs

Opérateur	Symbole	Entrées	Ce que ça fait
AND	`&`	A et B	1 là où les deux opérandes ont un 1 - masque et extrait des bits
OR	`\|`	A et B	1 là où un opérande a un 1 - définit et combine des bits
XOR	`^`	A et B	1 là où les opérandes diffèrent - bascule des bits
NOT	`~`	A seul	Inverse chaque bit dans la largeur choisie (l’opérande B est ignoré)
SHL	`<<`	A, compte B	Décale A à gauche de B ; des zéros entrent par la droite, les bits poussés au-delà de la largeur sont masqués
SHR	`>>`	A, compte B	Décalage logique à droite de B ; des zéros entrent par la gauche
ROL	`⟲`	A, compte B	Rotation à gauche de `B mod width` ; les bits sortant par le haut ré-entrent par le bas
ROR	`⟳`	A, compte B	Rotation à droite de `B mod width` ; les bits sortant par le bas ré-entrent par le haut

Comment l’utiliser

L’outil s’ouvre sur un échantillon en direct - XOR de l’hexa CA et 35 en 8 bits - donc un résultat est calculé dès le premier rendu. Modifiez un opérande et le panneau se met à jour instantanément.
Choisissez une largeur (8/16/32/64 bits) dans la barre d’outils - elle masque chaque valeur et chaque résultat.
Choisissez une opération dans la rangée d’opérateurs (de AND à ROR). Sélectionner NOT désactive l’opérande B.
Tapez Opérande A (et Opérande B pour les opérations binaires ; pour les décalages et rotations, B est le compte). L’interrupteur BIN/OCT/DEC/HEX au-dessus de chaque opérande fixe sa base - les préfixes comme 0x / 0b / 0o sont retirés automatiquement.
Lisez le panneau de résultat : lignes Décimal, Hexa, Octal et Binaire, plus la grille de bits (MSB à gauche, LSB à droite, les bits surlignés sont à 1). Copier le résultat copie les quatre lignes ; Copier le lien de partage encode tout le calcul dans l’URL.
Échantillon restaure l’exemple intégré ; Effacer vide les deux opérandes.

Exemples

Chaque valeur ci-dessous est la sortie réelle de l’outil pour l’entrée donnée.

XOR sur deux octets hexa (8 bits) - l’échantillon par défaut

width: 8-bit   op: XOR
A (hex): CA  → 1100 1010
B (hex): 35  → 0011 0101
result: dec 255 · hex 0xff · oct 0o377 · bin 1111 1111  (every bit set)

Masquer avec AND (32 bits)

A (hex): DEADBEEF   B (hex): 0000FFFF
result: dec 48879 · hex 0x0000beef · bin 0000 0000 0000 0000 1011 1110 1110 1111

NOT et décalages (8 bits)

op: NOT   A (hex): 0F, B: -        → dec 240 · hex 0xf0 · bin 1111 0000
op: SHL   A (hex): 01, B (dec): 4  → dec 16  · hex 0x10 · bin 0001 0000
op: SHR   A (hex): 08, B (dec): 1  → dec 4   · hex 0x04 · bin 0000 0100

Les rotations bouclent dans la largeur (8 bits)

op: ROL   A (hex): 80, B (dec): 1  → dec 1   · hex 0x01 · bin 0000 0001
  (1000 0000 rotated left by 1: the top bit wraps around to bit 0)
op: ROR   A (hex): 01, B (dec): 1  → dec 128 · hex 0x80 · bin 1000 0000
  (0000 0001 rotated right by 1: bit 0 wraps around to the top)

Les opérandes négatifs sont normalisés (8 bits)

A (dec): -1   op: AND   B (dec): 1
result: dec 1 · hex 0x01 · bin 0000 0001
  (-1 becomes 1111 1111, the 8-bit two's-complement pattern, before the op)

Bon à savoir

Masquage en complément à deux : chaque valeur est normalisée vers le motif non signé de la largeur avant l’opération, et le résultat est masqué en retour - donc NOT 0x0F en 8 bits donne 0xf0, jamais un nombre négatif géant, et -1 en 8 bits se comporte comme 0xff.
Les décalages perdent le débordement : 0xFF << 1 en 8 bits donne 0xfe - le bit poussé au-delà de la largeur disparaît, exactement comme avec les entiers natifs à largeur fixe.
Les rotations bouclent : ROL/ROR tournent de count mod width, donc une rotation de la largeur elle-même est un no-op.
Partageable : opérandes, bases, opération et largeur sont tous encodés dans l’URL - ouvrez le lien et le calcul exact est restauré.
Privé : tout le calcul est local - rien n’est envoyé nulle part.
Outils liés : Number Base Converter, JSON Formatter, Cron Expression Explainer.