Le cours « Bases numériques et opérations binaires » est un tutoriel interactif en 17 niveaux qui transforme le binaire, concept abstrait, en une rangée d'interrupteurs à portée de main : saisissez un nombre et ses quatre écritures — binaire, octale, décimale, hexadécimale — se mettent à jour ensemble ; allumez ou éteignez un bit et la valeur change aussitôt ; appliquez un AND / OR / XOR / décalage à deux nombres et le résultat s'affiche aligné bit par bit ; entrez un décimal et voyez-le se décomposer en signe, exposant et mantisse, avec le décimal qu'il vaut exactement en double précision. Chaque niveau a un objectif concret — convertir un nombre, atteindre 200, écrire le complément à deux de −5, calculer 5 << 3 — et le validateur répond immédiatement.

Le cours se divise en quatre parties : conversion de bases (binaire ↔ décimal, puissances de 2, pourquoi l'hexadécimal et l'octal sont des « sténographies ») ; nombres signés (comment le complément à deux change la soustraction en addition, pourquoi un dépassement fait passer 127 + 1 à −128) ; opérations bit à bit (masque AND, activation OR, inversion XOR, décalages multiplicatifs, et leur application directe aux bits de permission Linux 755) ; nombres flottants (la disposition des champs IEEE 754 et la vraie raison de 0.1 + 0.2 !== 0.3).

Comptez environ 45 minutes. Pour les débutants en programmation, les développeurs qui préparent un entretien, et tous ceux qui vérifient chaque fois 0x1F, & 0xFF ou chmod 644 ; aucune base mathématique n'est requise, savoir additionner suffit.

1. 01Objectif et panneauxl'objectif est en haut de chaque niveau ; en dessous, les panneaux changent selon le niveau — le panneau « Valeur » propose un champ de saisie, les quatre lectures de base et une rangée de bascules cliquables, avec interprétation signée / non signée ; le panneau « Opérations » donne deux opérandes et un opérateur, résultat aligné bit par bit ; le panneau « Permissions » offre 9 bascules rwx et une lecture octale ; le panneau « Flottants » prend un décimal et affiche la décomposition en champs 32 / 64 bits avec le développement décimal exact.
2. 02Manipuler et observerchangez la saisie, cliquez les bits, changez la largeur — toutes les lectures suivent en direct. Observer fait partie de l'apprentissage : passez 128 en interprétation signée et vous le voyez devenir −128.
3. 03Répondrela plupart des niveaux demandent un décimal, une chaîne binaire, de l'hexadécimal ou de l'octal dans le champ de réponse ; les niveaux « bascules » exigent de composer la valeur uniquement en cliquant ; le dernier niveau sur les flottants est une question à choix multiple.
4. 04Validationla barre de résultat indique immédiatement si c'est juste ou ce qui manque ; les réponses binaires acceptent les zéros de tête (sauf aux niveaux qui exigent « exactement 8 bits »), l'hexadécimal ignore la casse et accepte le préfixe 0x.
5. 05Indices, réponses et progression« Indice » donne une piste, « Voir la réponse » affiche la réponse de référence et permet de la remplir ; la progression est stockée dans le navigateur et ?lesson=n mène directement à un niveau.

Le niveau 9, « complément à deux », demande d'écrire le complément à deux de −5 sur 8 bits :

Le niveau 16, « champs IEEE 754 », prend 0.15625 et le panneau affiche :

Valeur absolue   5        0 0 0 0 0 1 0 1
Inversion        1 1 1 1 1 0 1 0
Plus 1           1 1 1 1 1 0 1 1      ← réponse 11111011
Vérification     non signé 251, signé 251 − 256 = −5   ✓

0.15625 = 0.00101₂ = 1.01₂ × 2⁻³
Signe      0
Exposant   −3 + 127 = 124 = 01111100      ← réponse 124
Mantisse   01000000000000000000000 (1 implicite en tête)
32 bits    0 01111100 01000000000000000000000 = 0x3E200000

Niveaux 1–2 : poids des bits et conversions

Toute base est une « somme de poids ». En décimal, 203 = 2×100 + 0×10 + 3×1 ; en binaire, 1011 = 1×8 + 0×4 + 1×2 + 1×1 = 11. De droite à gauche, les poids valent 1, 2, 4, 8, 16, 32, 64, 128… Convertir du binaire en décimal revient à additionner les poids des bits à 1 ; dans l'autre sens, on divise par 2 en notant les restes, ou on soustrait gloutonnement les puissances de 2 de la plus grande à la plus petite (les bascules du niveau 7 visualisent exactement ce procédé).

Niveau 3 : pourquoi 1024

$2^{10} = 1024$, à 2,4 % de 1000 : voilà pourquoi on a longtemps écrit KB pour 1024 octets. D'où une confusion qui dure encore : les fabricants de disques étiquettent 1 GB sur la base de $10^9$, les systèmes d'exploitation calculent en $2^{30}$, et un disque de 500 GB s'affiche à 465 GiB. L'IEC a donc défini KiB, MiB et GiB (préfixes binaires) ; Linux et macOS les adoptent peu à peu, Windows affiche toujours GB tout en calculant en GiB. À retenir : $2^8 = 256$, $2^{10} = 1024$, $2^{16} = 65536$, $2^{32} \approx 4.29 \times 10^9$.

Niveaux 4–6 : hexadécimal et octal

Le binaire est trop long à lire pour un humain. L'hexadécimal (0–9 puis A–F) encode 4 bits par symbole : un octet fait exactement deux chiffres — 11111111 = FF, 10110110 = B6. La conversion se fait sans passer par le décimal : on découpe le binaire par groupes de 4 bits en partant de la droite et on lit la table, ce que travaille le niveau 5. L'octal encode 3 bits par symbole ; il servait aux machines de 12, 24 et 36 bits et survit aujourd'hui dans les permissions Linux (755) et l'échappement C \012. Préfixes en programmation : 0x hexadécimal, 0o octal, 0b binaire.

Niveau 7 : le bit est un interrupteur

Chaque entier positif n'a qu'une seule écriture binaire : un nombre de 8 bits peut donc servir de 8 interrupteurs indépendants (drapeaux) — flags = READ | WRITE, if (flags & EXEC). Le font-weight en CSS, les permissions de fichier Unix ou les champs de drapeaux des en-têtes réseau sont empaquetés ainsi. Au niveau 7, il faut composer 200 en ne cliquant que des bascules : gloutonnement depuis le bit fort — 200 ≥ 128 allumé, reste 72 ≥ 64 allumé, reste 8 = 2³ allumé, soit 11001000.

Niveaux 8–9 : complément à deux

Comment stocker les négatifs ? L'intuition est de réserver un bit au signe, mais on aurait deux zéros (« +0 » et « −0 ») et un circuit d'addition à traiter au cas par cas. La règle du complément à deux est : le bit de poids fort à 1 signifie négatif, et la valeur vaut la valeur non signée moins $2^n$. Sur 8 bits, 11111111 vaut 255, donc 255 − 256 = −1 ; 10000000 vaut −128. Pour obtenir le complément à deux d'un négatif : écrire la valeur absolue, inverser tous les bits, ajouter 1 — pour −5 : 00000101 → 11111010 → 11111011.

L'astuce du complément à deux, c'est que l'addition n'a pas besoin de connaître les signes : −5 + 5 = 11111011 + 00000101 = 1 00000000, et une fois le report du 9e bit abandonné, on obtient bien 0. La soustraction devient « ajouter le complément à deux », et le processeur n'a besoin que d'un additionneur. Sur 8 bits, la plage va de −128 à 127 : un négatif de plus qu'un positif, car 0 occupe une place du côté positif.

Niveau 10 : dépassement

Les bits sont limités : qui additionne trop repasse de l'autre côté. En int8, 127 = 01111111 ; plus 1 donne 10000000, soit −128 en complément à deux. En C, Java et Go, le dépassement d'entier se produit silencieusement ainsi ; en JavaScript, le Number ordinaire est un flottant et ne déborde pas, mais Int8Array, |0 et toutes les opérations bit à bit travaillent sur 32 bits en complément à deux, et (2 ** 31) | 0 donne −2147483648. Le fameux problème de l'an 2038 vient du débordement des secondes signées 32 bits le 2038-01-19 03:14:07 UTC ; les « scores qui passent en négatif » ou les « pièces d'or remises à zéro » des jeux d'autrefois, c'est la même chose.

Niveaux 11–13 : AND, OR, XOR

Chacune des trois opérations logiques bit à bit a un usage attitré :

« Éteindre » un bit combine AND et NOT : flags & ~FLAG. Les deux identités du XOR, $x \oplus x = 0$ et $x \oplus 0 = x$, sont à la racine de tous ses usages : a ^= b; b ^= a; a ^= b échange deux nombres, et pour trouver l'élément d'un tableau présent un nombre impair de fois, il suffit de XORer tous les nombres entre eux.

Niveau 14 : décalages

Décaler de n bits vers la gauche équivaut à multiplier par $2^n$ (des zéros entrent à droite) ; vers la droite, à diviser par $2^n$ en arrondissant vers le bas. 5 << 3 = 101000 = 40. Le décalage est la multiplication/division la moins chère ; plus souvent, il emballe de petits champs dans un entier : (r << 16) | (g << 8) | b assemble trois canaux 0–255 en une couleur 24 bits, et (rgb >> 8) & 0xFF récupère G. Attention, il existe deux décalages à droite : l'arithmétique >> conserve le bit de signe (un négatif reste négatif), le logique >>> entre des zéros. En JavaScript, les décalages s'effectuent sur 32 bits : 1 << 31 donne −2147483648 et 1 << 32 vaut 1 << 0 = 1, car la quantité est traitée modulo 32.

Niveau 15 : chmod 755

Les permissions de fichier Linux sont 9 bits : 3 pour le propriétaire, 3 pour le groupe, 3 pour les autres, dans l'ordre lecture r = 4, écriture w = 2, exécution x = 1. La somme de chaque triplet donne un chiffre octal : rwxr-xr-x = 7, 5, 5 → 755 ; rw-r--r-- = 644. C'est l'application la plus directe des poids et des masques au quotidien : chmod u+x fait un OR avec 0o100, chmod o-w un AND avec ~0o002. Trois bits supplémentaires peuvent précéder (setuid, setgid, sticky), d'où les quatre chiffres de 4755.

Niveau 16 : les trois champs IEEE 754

Un flottant est une notation scientifique en base 2 :

Simple précision 32 bits = 1 bit de signe s + 8 bits d'exposant e (biais 127) + 23 bits de mantisse f ; double précision 64 bits = 1 + 11 (biais 1023) + 52. La mantisse ne stocke que la partie fractionnaire : le 1 de la partie entière est implicite, un bit de précision gagné. L'exposant est décalé du biais pour que la comparaison bit à bit des flottants reste monotone comme celle des entiers. 0.15625 = $0.00101_2$ = $1.01_2 \times 2^{-3}$ : le champ d'exposant vaut −3 + 127 = 124 = 01111100, et le champ de mantisse 01 suivi de zéros.

Quelques codages particuliers : exposant tout à 0 = dénormal (valeurs extrêmement proches de 0 et ±0) ; exposant tout à 1 avec mantisse nulle = ±∞ ; exposant tout à 1 avec mantisse non nulle = NaN — voilà pourquoi 0/0 est NaN alors que 1/0 est Infinity, et pourquoi NaN a de nombreux motifs de bits tout en n'étant jamais égal à lui-même.

Niveau 17 : 0.1 + 0.2

Un décimal binaire ne peut représenter exactement qu'une somme de puissances négatives de 2 : 0.5, 0.25, 0.125… $\tfrac{1}{10}$ s'écrit en binaire comme le nombre périodique $0.0\overline{0011}$, et une mantisse de 52 bits doit arrondir. En double précision, 0.1 vaut donc exactement

un peu plus que 0.1 ; 0.2 aussi est un peu plus grand ; leur somme arrondie donne 0.3000000000000000444…, tandis que le double le plus proche du littéral 0.3 est 0.29999999999999998889… — deux nombres binaires différents, donc 0.1 + 0.2 === 0.3 est faux. Ce n'est pas un bug de JavaScript : tout langage en IEEE 754 (Python, Java, C, Go) fait pareil.

La parade dépend du contexte : argent → entiers en centimes ou bibliothèque décimale (decimal, BigDecimal, Decimal.js) ; comparaison → marge d'erreur Math.abs(a − b) < ε ; affichage → toFixed(2) seulement à la toute fin ; comptage → des entiers, un double représentant exactement tout entier jusqu'à $\pm 2^{53}$, au-delà il faut BigInt. La question à choix multiple du dernier niveau (« le 0.1 stocké est-il plus grand ou plus petit que la valeur réelle ? ») a pour réponse « plus grand » : il suffit de lire les chiffres 55511… à partir du 18e de son développement exact.

Largeurs

le panneau Valeur gère 8 / 16 / 32 bits ; les entiers 64 bits et les opérations bit à bit sur BigInt ne sont pas traités.

Flottants

uniquement la disposition des champs IEEE 754 binary32 / binary64 et le développement décimal exact ; ni modes d'arrondi, ni performance des dénormaux, ni Math.fround, ni demi-précision, ni bfloat16.

Sémantique des opérations bit à bit

les décalages sont décrits selon JavaScript (32 bits signés) ; en C, le décalage à gauche d'un négatif et les décalages à quantité trop grande sont des comportements indéfinis que le cours ne détaille pas.

Bits de permission

seuls les 9 bits de base et la notation octale sont traités ; setuid / setgid / sticky et les ACL sont mentionnés dans le texte, mais absents des panneaux.

Validation

les réponses numériques sont comparées exactement ; le binaire accepte les zéros de tête (sauf aux niveaux marqués « 8 bits ») ; l'hexadécimal ignore la casse et accepte 0x.

Ce qu'il ne fait pas

ce n'est pas un convertisseur par lot (pour de vraies données, utilisez « Convertisseur de bases » ou « Calculateur chmod »), ni un outil d'analyse d'erreurs flottantes, ni un cours sur l'implémentation au niveau du processeur.

• « 1 KB = 1000 octets » ou « = 1024 octets » : les deux existent. Disques et réseaux comptent en 1000, mémoire et systèmes d'exploitation souvent en 1024 (KiB chez l'IEC). Regardez le contexte, ou la présence d'un « i ».
• « un négatif, c'est un positif dont le bit de poids fort passe à 1 » : ça, c'est le « signe-magnitude », presque aucun matériel ne le stocke ainsi. En complément à deux, 10000000 vaut −128 et non −0, et −1 s'écrit avec tous les bits à 1.
• « >> revient à diviser par 2 » : pour un négatif, c'est un arrondi vers −∞, pas vers zéro : −5 >> 1 donne −3, alors que Math.trunc(−5 / 2) donne −2.
• « les flottants sont imprécis » : chaque flottant vaut exactement un certain décimal binaire ; ce qui est imprécis, c'est la conversion décimal → binaire. 0.5, 0.25 et 3.0 sont exacts.
• « toFixed suffit pour les montants » : toFixed ne fait qu'arrondir à l'affichage, l'erreur des calculs intermédiaires est déjà accumulée ; un montant doit être en centimes entiers dès le départ.
• « JavaScript n'a pas d'entiers, donc pas de dépassement » : les opérations bit à bit, les Int32Array et | 0 travaillent sur 32 bits en complément à deux et peuvent déborder ; un Number perd la précision entière au-delà de $2^{53}$.

Le cours tourne entièrement en local dans le navigateur : conversions de bases, opérations bit à bit, décomposition des champs flottants et développement exact sont des calculs purs dans la page, sans requête vers un serveur ; la progression est conservée dans le localStorage de la machine.

• IEEE, IEEE 754-2019, IEEE Standard for Floating-Point Arithmetic — disposition des champs, biais, valeurs spéciales et règles d'arrondi de binary32 / binary64 : https://standards.ieee.org/ieee/754/6210/(consulté le 2026-09-09)
• David Goldberg, What Every Computer Scientist Should Know About Floating-Point Arithmetic, ACM Computing Surveys 23(1), 1991 — l'article classique sur l'erreur d'arrondi, le développement exact et « pourquoi 0.1 ne se stocke pas exactement » : https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html(consulté le 2026-09-09)
• ECMA-262, ECMAScript Language Specification, type Number et opérations abstraites ToInt32 / ToUint32 — la base normative des opérations bit à bit de JavaScript, effectuées sur 32 bits en complément à deux : https://tc39.es/ecma262/#sec-ecmascript-language-types-number-type(consulté le 2026-09-09)
• IEEE / The Open Group, POSIX.1-2024, outil chmod — définition des modes symbolique et octal : https://pubs.opengroup.org/onlinepubs/9799919799/utilities/chmod.html(consulté le 2026-09-09)
• IEC 80000-13:2008, Quantities and units — Part 13: Information science and technology — définition des préfixes binaires KiB / MiB / GiB : https://www.iso.org/standard/31898.html(consulté le 2026-09-09)
• Charles Petzold, Code: The Hidden Language of Computer Hardware and Software, 2e éd., Microsoft Press, 2022 — des interrupteurs à l'additionneur puis au complément à deux, expliqué simplement.