Convertisseur de bases

Ce que fait cet outil

Un même nombre peut s’écrire dans de nombreuses bases, et les programmeurs passent sans cesse de l’une à l’autre parmi quatre d’entre elles : le binaire parce que c’est ce que contient le matériel, l’hexadécimal parce qu’il en est une abréviation lisible, le décimal parce que c’est ainsi que les humains pensent, et l’octal parce que les permissions de fichiers et quelques systèmes anciens l’utilisent encore. Saisissez une valeur dans l’un des champs et les autres suivent, avec un champ supplémentaire réglable sur n’importe quelle base de 2 à 36.

Ce qui le distingue d’une calculatrice scolaire, c’est le sélecteur de largeur et la grille de bits. Choisissez 8, 16, 32 ou 64 bits et les nombres négatifs prennent leur vraie représentation machine au lieu d’un signe moins, et chaque bit devient cliquable.

Ce qu’est vraiment une base

Une base, c’est le nombre de chiffres dont vous disposez avant d’en manquer et de devoir retenir. Le décimal en a dix, donc après 9 vient 10. Le binaire en a deux, donc après 1 vient 10. La position de chaque chiffre est une puissance de la base, et c’est tout :

1011           # le nombre, en base 2
1 x 8 = 8      # bit 3
0 x 4 = 0      # bit 2
1 x 2 = 2      # bit 1
1 x 1 = 1      # bit 0
8+0+2+1 = 11   # le total, en décimal

Les bases au-delà de dix ont besoin de plus de dix symboles, elles empruntent donc des lettres : l’hexadécimal va de 0-9 puis a-f, où a vaut 10 et f vaut 15. Cela se poursuit jusqu’à la base 36, qui utilise chaque chiffre et chaque lettre — la plus grande base que l’on puisse écrire avec l’alphabet simple, et la raison pour laquelle cet outil s’arrête là.

Pourquoi l’hexadécimal, et pas autre chose

L’hexadécimal est répandu pour une raison précise : 16 vaut 2 puissance 4, donc un chiffre hex couvre exactement quatre bits. La conversion entre hex et binaire devient une simple lecture de table, sans arithmétique — chaque chiffre hex se développe en ses quatre bits, indépendamment de ses voisins.

d    e    a    d
1101 1110 1010 1101   # chaque chiffre hex est son propre quartet

L’octal fonctionne pareillement avec trois bits par chiffre, puisque 8 vaut 2 puissance 3 — d’où les permissions Unix en octal : trois bits de permission par groupe d’utilisateurs tiennent exactement dans un chiffre. Le décimal n’entretient aucune relation de ce genre avec le binaire, et c’est pourquoi passer de l’un à l’autre demande une vraie division plutôt qu’une lecture de table.

C’est aussi pourquoi le champ binaire est ici groupé par quatre et le champ hex par deux : les groupes coïncident avec les frontières qui comptent, si bien que vous lisez un quartet ou un octet à l’écran sans compter.

Nombres négatifs et complément à deux

Un nombre négatif n’a pas de forme binaire en soi. Il n’y a pas de signe moins dans un registre — seulement des bits — le signe doit donc être encodé dans les bits eux-mêmes, ce qui oblige à décider combien il y en a. C’est la raison d’être du sélecteur de largeur, et pourquoi la réponse change quand vous en changez.

Le schéma qu’emploie toute machine moderne est le complément à deux : pour représenter un nombre négatif, on prend sa forme positive, on inverse chaque bit et on ajoute un. Résultat : le bit de poids fort finit par signifier « négatif », et l’addition ordinaire continue de fonctionner sans cas particulier pour les signes.

0000 0101   # 5
1111 1010   # chaque bit inversé
1111 1011   # plus un : -5 en un octet, ou fb en hex

Élargissez le registre et le même nombre reçoit un autre motif : -5 s’écrit fb sur 8 bits, fffb sur 16 et fffffffb sur 32. La valeur n’a pas changé ; le nombre de bits qui la portent, si. Changer de largeur dans cet outil montre exactement cela.

Pourquoi 0xFF vaut à la fois 255 et -1

Les bits ff ne disent pas s’ils sont signés. Un octet contenant 1111 1111 se lit 255 si le code qui le charge a déclaré un type non signé, et -1 s’il en a déclaré un signé. Rien dans l’octet lui-même ne distingue les deux — le type est une affirmation du programme sur des bits qui ne portent pas cette information.

C’est la source de toute une famille de bogues réels : une somme de contrôle qui ressort négative, un octet lu dans un fichier qui se compare comme inférieur à zéro, un char C qui se comporte autrement sur ARM que sur x86 parce que sa signature dépend de l’implémentation. Chaque fois que les lectures signée et non signée diffèrent, cet outil affiche les deux, car l’écart est en général précisément ce que vous cherchiez.

La grille de bits

Chaque bit de la valeur courante est affiché avec son numéro de position, et un clic l’inverse. Les bases se mettent à jour aussitôt, ce qui rend certaines questions bien plus faciles qu’à la main :

• Quel bit est activé dans cette valeur de drapeaux — cliquez-les et lisez les positions.
• Quel est le masque pour les bits 4 et 7 — activez ces deux-là et lisez l’hex.
• Que fait l’activation du bit de poids fort sur une valeur signée — elle la rend négative, visiblement.
• Cette valeur est-elle une puissance de deux — une puissance de deux a exactement un bit activé.

Le bit 0 est le bit de poids faible et se trouve à droite, convention universelle et raison pour laquelle la grille reste de gauche à droite même sur une page qui se lit à l’envers. Les rangées font huit bits pour que les frontières d’octets se voient d’un coup d’œil.

Les grands nombres restent exacts

Les nombres JavaScript sont des doubles, qui ne contiennent exactement les entiers que jusqu’à 2^53 — environ 9 millions de milliards. Une valeur 64 bits peut dépasser cela, et un convertisseur bâti sur des nombres ordinaires l’arrondira en silence, produisant une chaîne hex plausible et fausse dans ses derniers chiffres.

Ici tout repose sur des entiers de précision arbitraire, si bien qu’une valeur 64 bits complète se convertit exactement. Le mode précision arbitraire va plus loin et supprime la limite entièrement — utile pour les valeurs cryptographiques et les grands identifiants — mais notez que sans largeur fixe il n’y a pas de complément à deux : un nombre négatif y porte simplement un signe moins dans chaque base.