Conversion de bases numériques : binaire, hexadécimal, octal et décimal pour développeurs

Un après-midi, vous fixez 0x7FFF5FBFF8C0 dans le débogueur, puis vous modifiez #FF5733 dans un fichier CSS, puis vous tapez chmod 755 dans le terminal. Trois représentations différentes, la même arithmétique derrière. Si vous devez réfléchir pour convertir entre hexadécimal et binaire, ou si vous vous demandez pourquoi Unix utilise l’octal pour les permissions, cet article va assembler les pièces du puzzle.

Nous couvrons les quatre systèmes numériques du quotidien en programmation, trois méthodes de conversion à retenir, et du code concret en JavaScript, Python, Go et C. Pour convertir un nombre sans lire la théorie, ouvrez notre convertisseur de base — il gère toute base de 2 à 36 avec une précision arbitraire.

Les quatre systèmes numériques du développeur

Chaque base existe en programmation pour une raison pratique.

Binaire (base 2) — Le langage de la machine

Deux chiffres : 0 et 1. Un transistor est soit passant, soit bloqué — cette contrainte physique impose le binaire. Vous le rencontrez dans les masques de bits, les drapeaux, les opérations bit à bit et les calculs de sous-réseaux IP.

Le binaire devient vite encombrant. Le nombre 255 en décimal s’écrit 11111111 en binaire — huit chiffres pour trois chiffres décimaux. C’est pourquoi les développeurs écrivent rarement du binaire brut, sauf quand la position de chaque bit compte.

Octal (base 8) — Le raccourci Unix

Huit chiffres : 0 à 7. Chaque chiffre octal correspond exactement à trois bits binaires, d’où l’utilisation de l’octal pour les permissions Unix — chmod 755 compresse trois groupes de trois bits en trois chiffres lisibles.

L’octal était plus répandu à l’époque du PDP-11, quand les mots machine se divisaient en groupes de 3 bits. Aujourd’hui, il apparaît surtout dans les permissions Unix et dans les littéraux C préfixés par 0 (une source de bugs quand quelqu’un écrit 0177 en pensant obtenir le décimal 177).

Décimal (base 10) — La valeur par défaut humaine

Dix chiffres : 0 à 9. Votre cerveau pense en base 10 — numéros de port, indices de tableau, codes HTTP, dimensions en pixels. L’ordinateur ne fonctionne pas en décimal, mais les humains si, donc tout nombre affiché à l’écran sort en base 10.

Hexadécimal (base 16) — Le couteau suisse du développeur

Seize symboles : 0-9 et A-F. Chaque chiffre hex représente exactement quatre bits (un nibble). Deux chiffres hex = un octet. Toujours.

Vous verrez l’hexadécimal dans les adresses mémoire (0x7FFF5FBFF8C0), les couleurs CSS (#FF5733), les adresses MAC (00:1A:2B:3C:4D:5E), les UUID et les empreintes de hachage. C’est la langue commune de la programmation au niveau de l’octet.

Testez la conversion entre les quatre systèmes dans notre convertisseur de base — saisissez une valeur dans n’importe quelle base et les autres se mettent à jour instantanément.

Comment fonctionne la conversion de bases : trois méthodes fondamentales

Pas besoin d’outil pour convertir entre les bases, même si ça va plus vite avec. Trois méthodes couvrent tous les cas.

Méthode 1 — Développement positionnel (toute base → décimal)

Chaque système positionnel fonctionne de la même manière : chaque chiffre est multiplié par la base élevée à la puissance de sa position, en comptant de droite à gauche à partir de zéro.

Binaire 1011 :

1×2³ + 0×2² + 1×2¹ + 1×2⁰
= 8   + 0    + 2    + 1
= 11

Hex FF :

15×16¹ + 15×16⁰
= 240   + 15
= 255

En code, la plupart des langages disposent d’une fonction d’analyse :

parseInt('1011', 2)   // 11
parseInt('FF', 16)    // 255
parseInt('755', 8)    // 493

Méthode 2 — Division successive (décimal → toute base)

Pour aller dans l’autre sens, divisez le nombre décimal par la base cible de façon répétée et collectez les restes. Lisez-les de bas en haut.

Décimal 255 → hexadécimal :

255 ÷ 16 = 15  reste 15 (F)
 15 ÷ 16 =  0  reste 15 (F)
→ De bas en haut : FF

Décimal 42 → binaire :

42 ÷ 2 = 21  reste 0
21 ÷ 2 = 10  reste 1
10 ÷ 2 =  5  reste 0
 5 ÷ 2 =  2  reste 1
 2 ÷ 2 =  1  reste 0
 1 ÷ 2 =  0  reste 1
→ De bas en haut : 101010

bin(42)    # '0b101010'
hex(255)   # '0xff'
oct(493)   # '0o755'

Méthode 3 — Groupement de bits (binaire ↔ hex/octal direct)

C’est la méthode que les développeurs expérimentés utilisent au quotidien. Puisque 16 = 2⁴ et 8 = 2³, la conversion entre binaire et hex (ou octal) se fait par simple groupement — sans calcul.

Binaire → Hex : Groupez par nibbles (4 bits) depuis la droite. Complétez le groupe le plus à gauche avec des zéros si nécessaire.

Binaire :     1010 1111
Hexadécimal :  A    F
→ AF

Binaire → Octal : Groupez par triplets (3 bits) depuis la droite.

Binaire : 111 101 101
Octal :    7   5   5
→ 755

La table de correspondance des nibbles mérite d’être mémorisée :

Binaire	Hex	Binaire	Hex
`0000`	0	`1000`	8
`0001`	1	`1001`	9
`0010`	2	`1010`	A
`0011`	3	`1011`	B
`0100`	4	`1100`	C
`0101`	5	`1101`	D
`0110`	6	`1110`	E
`0111`	7	`1111`	F

Une fois cette table assimilée, convertir du binaire en hex devient une lecture directe.

Conversion de bases dans chaque langage

Voici le code pratique dans les quatre langages où cette opération revient le plus souvent.

JavaScript / TypeScript

// Analyse : chaîne en base quelconque → nombre
parseInt('FF', 16)          // 255
parseInt('101010', 2)       // 42
parseInt('755', 8)          // 493

// Formatage : nombre → chaîne en base quelconque
(255).toString(16)          // 'ff'
(42).toString(2)            // '101010'
(493).toString(8)           // '755'

// Littéraux
const bin = 0b11111111;     // 255
const oct = 0o377;          // 255
const hex = 0xff;           // 255

// BigInt pour les valeurs au-delà de 2⁵³
const big = BigInt('0xFFFFFFFFFFFFFFFF');
big.toString(2)             // 64 uns
big.toString(10)            // '18446744073709551615'

Python

# Décimal → autres bases (chaînes préfixées)
bin(255)          # '0b11111111'
oct(493)          # '0o755'
hex(255)          # '0xff'

# Autres bases → décimal
int('11111111', 2)    # 255
int('FF', 16)         # 255
int('755', 8)         # 493

# Sortie formatée avec remplissage
f'{255:08b}'      # '11111111'  (binaire sur 8 chiffres)
f'{255:02x}'      # 'ff'       (hex minuscule)
f'{255:02X}'      # 'FF'       (hex majuscule)

# Précision arbitraire native en Python
big = int('F' * 64, 16)   # nombre de 256 bits, pas de dépassement

Go

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // Formatage : int → chaîne en base quelconque
    fmt.Println(strconv.FormatInt(255, 16))  // "ff"
    fmt.Println(strconv.FormatInt(255, 2))   // "11111111"
    fmt.Println(strconv.FormatInt(493, 8))   // "755"

    // Analyse : chaîne en base quelconque → int
    n, _ := strconv.ParseInt("FF", 16, 64)  // 255
    fmt.Println(n)

    // Verbes Printf
    fmt.Printf("%b %o %x %d\n", 255, 255, 255, 255)
    // 11111111 377 ff 255
}

C

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

int main() {
    // Sortie en décimal, octal, hexadécimal
    printf("%d %o %x\n", 255, 255, 255);
    // 255 377 ff

    // Analyse depuis n'importe quelle base
    long val = strtol("FF", NULL, 16);   // 255
    long bin = strtol("101010", NULL, 2); // 42

    // Pas de printf binaire natif — extraction bit par bit :
    uint8_t byte = 0xAF;
    for (int i = 7; i >= 0; i--)
        putchar(((byte >> i) & 1) ? '1' : '0');
    // 10101111

    return 0;
}

Scénarios concrets de conversion de bases

Cinq situations où la conversion de bases fait partie du travail quotidien.

1. Débogage d’adresses mémoire

Le débogueur affiche un pointeur à 0x7FFF5FBFF8C0. Convertir les deux derniers octets en binaire — 1000 1100 0000 — révèle un alignement sur 64 octets (six zéros finaux). L’alignement impacte les performances du cache, les opérations SIMD et les E/S mappées en mémoire.

L’arithmétique de pointeurs est plus lisible en hex. Un décalage de 0x100 depuis une adresse de base, c’est exactement 256 octets — une page dans beaucoup de systèmes embarqués.

2. Couleurs CSS hexadécimales ↔ RGB

La couleur #FF5733 est composée de trois octets en paires hexadécimales :

Paire	Hex	Décimal	Canal
`FF`	FF	255	Rouge (max)
`57`	57	87	Vert
`33`	33	51	Bleu

Le raccourci #F00 se développe en #FF0000 — rouge pur. La variante à 8 chiffres #FF573380 ajoute un canal alpha où 80 (décimal 128) correspond à environ 50 % d’opacité.

3. Permissions de fichiers Unix (octal)

chmod 755 se décompose ainsi :

7 → 111 → rwx  (propriétaire : lecture + écriture + exécution)
5 → 101 → r-x  (groupe : lecture + exécution)
5 → 101 → r-x  (autres : lecture + exécution)

Chaque chiffre octal encode un groupe de permissions car trois bits de permission (lecture=4, écriture=2, exécution=1) correspondent à un seul chiffre octal (0-7). Combinaisons courantes :

Octal	Binaire	Permissions	Usage typique
`755`	`111 101 101`	`rwxr-xr-x`	Exécutables, dossiers
`644`	`110 100 100`	`rw-r--r--`	Fichiers standards
`700`	`111 000 000`	`rwx------`	Scripts privés
`600`	`110 000 000`	`rw-------`	Clés SSH, secrets

4. Calculs de sous-réseaux

Un masque /24 signifie 24 bits à 1 en tête :

11111111.11111111.11111111.00000000
→ 255.255.255.0

Pour trouver l’adresse réseau, appliquez un AND bit à bit entre l’IP et le masque :

192.168.1.37   → 11000000.10101000.00000001.00100101
255.255.255.0  → 11111111.11111111.11111111.00000000
Résultat AND   → 11000000.10101000.00000001.00000000
               → 192.168.1.0 (adresse réseau)

Les ingénieurs réseau jonglent constamment entre décimal (notation IP), binaire (calculs de masques) et hexadécimal (captures de paquets). Notre convertisseur de base permet de vérifier chaque octet visuellement.

5. Lecture des empreintes de hachage et des UUID

Une empreinte MD5 comme d41d8cd98f00b204e9800998ecf8427e contient 32 caractères hexadécimaux, soit 16 octets (128 bits). Chaque paire hex représente un octet.

Un UUID suit le format 8-4-4-4-12 en hexadécimal :

550e8400-e29b-41d4-a716-446655440000

32 chiffres hex séparés par des tirets — les mêmes 128 bits, mais segmentés différemment. Le nibble de version est en position 13 (le 4 dans 41d4 indique un UUID v4).

Générez des hachages avec notre générateur de hachage MD5 & SHA ou créez des UUID avec notre générateur d’UUID — les deux produisent une sortie hexadécimale.

Au-delà de la base 16 : base 36, base 64 et bases personnalisées

Les quatre bases standard couvrent la majorité des besoins, mais quelques autres apparaissent dans des contextes spécialisés.

Base 36 — Encodage alphanumérique compact

La base 36 utilise les 10 chiffres plus les 26 lettres (A-Z), offrant la représentation alphanumérique insensible à la casse la plus compacte possible. Les services de raccourcissement d’URL l’apprécient — identifiants de vidéos YouTube, liens courts et clés de bases de données utilisent souvent la base 36.

(1000000).toString(36)    // 'lfls'
parseInt('lfls', 36)      // 1000000

Le nombre 1 000 000 tient en quatre caractères. Difficile de faire plus court pour un identifiant compatible URL.

Base 64 — Encodage de données (pas un système numérique)

Le Base64 ressemble à une autre base, mais son rôle est différent. Au lieu de représenter une valeur numérique dans un système positionnel, le Base64 encode des données binaires arbitraires (images, fichiers, jetons JWT) en texte ASCII. Il utilise A-Z, a-z, 0-9, + et / — 64 symboles au total.

C’est un schéma d’encodage, pas un système numérique. Pour encoder et décoder du Base64, utilisez notre encodeur-décodeur Base64.

Bases arbitraires (2-36) et où elles apparaissent

Quelques autres bases surgissent à l’occasion :

Base 12 (duodécimal) : Horloge (12 heures), quantités (la douzaine). Certains mathématiciens jugent la base 12 préférable à la base 10 car 12 a plus de diviseurs.
Base 60 (sexagésimal) : Temps (60 secondes, 60 minutes) et angles (360°). Hérité des mathématiques babyloniennes.
Base 32 : L’encodage Base32 de Crockford pour des identifiants lisibles (exclut les caractères ambigus comme I, L, O). Également utilisé dans le geohashing.

Notre convertisseur de base prend en charge toute base entière de 2 à 36.

Opérations bit à bit et conversion de bases

Comprendre le binaire ne sert pas qu’à convertir des nombres — c’est le fondement des opérations bit à bit, omniprésentes en programmation système, jeux vidéo et systèmes de permissions.

const READ  = 0b100;  // 4
const WRITE = 0b010;  // 2
const EXEC  = 0b001;  // 1

// Combiner des permissions avec OR
const perms = READ | WRITE;  // 0b110 = 6

// Vérifier une permission avec AND
(perms & READ)  !== 0   // true  — lecture autorisée
(perms & EXEC)  !== 0   // false — exécution refusée

// Basculer une permission avec XOR
perms ^ WRITE   // 0b100 = 4 — écriture retirée

// Décalages
1 << 3    // 0b1000 = 8  (1 décalé de 3 vers la gauche)
0xFF >> 4  // 0b00001111 = 15  (décalage droit de 4 = division par 16)

Drapeaux de fonctionnalités, registres matériels, protocoles réseau, programmation graphique — tous reposent sur les opérations bit à bit. Quand le binaire se lit couramment, la manipulation de bits cesse d’être mystérieuse.

FAQ

Quels sont les quatre principaux systèmes numériques en programmation ?

Binaire (base 2), octal (base 8), décimal (base 10) et hexadécimal (base 16). Le binaire est la forme physique des données dans le matériel. L’octal sert aux permissions Unix. Le décimal est la représentation par défaut pour les humains. L’hexadécimal compresse le binaire — chaque chiffre hex correspond à exactement 4 bits.

Comment convertir du binaire en hexadécimal ?

Groupez les bits par 4 depuis la droite, complétez le dernier groupe à gauche avec des zéros. Faites correspondre chaque groupe : 0000=0, 0001=1, …, 1010=A, …, 1111=F. Exemple : binaire 10101111 → groupes 1010 1111 → hex AF. Cela fonctionne car 16 = 2⁴.

Comment convertir de l’hexadécimal en décimal ?

Multipliez chaque chiffre hex par 16 élevé à la puissance de sa position (la plus à droite = 0), puis additionnez. Rappel : A=10, B=11, C=12, D=13, E=14, F=15. Exemple : hex FF = 15×16¹ + 15×16⁰ = 240 + 15 = 255. En code : JavaScript parseInt('FF', 16), Python int('FF', 16).

Pourquoi les développeurs utilisent-ils l’hexadécimal plutôt que le binaire ?

L’hex est compact. Chaque chiffre hex correspond à exactement 4 bits, donc 11111111 00001010 en binaire se réduit à FF0A en hex — bien plus court et facile à lire. L’hex est le standard pour les adresses mémoire, les couleurs CSS (#FF5733), les adresses MAC, les sorties de hachage et le format UUID.

Qu’est-ce qu’un nibble et quel rapport avec la conversion hex ?

Un nibble est un groupe de 4 bits — un demi-octet. Un nibble correspond à exactement un chiffre hexadécimal, ce qui rend la conversion binaire-hex triviale. Un octet = deux nibbles = deux chiffres hex. Cette correspondance nette de 4 bits est la raison pour laquelle l’hex s’est imposé pour représenter les données au niveau de l’octet.

Pourquoi les permissions Unix utilisent-elles l’octal ?

Chaque groupe de permissions comprend trois bits : lecture (4), écriture (2), exécution (1). Il y a trois groupes (propriétaire, groupe, autres). Puisque 2³ = 8, trois bits de permission correspondent à un seul chiffre octal. 755 signifie propriétaire=7 (rwx), groupe=5 (r-x), autres=5 (r-x). L’octal est la base naturelle pour les groupements de 3 bits.

Comment gérer les nombres supérieurs à 2⁵³ en JavaScript ?

Utilisez BigInt. Ajoutez n à un littéral ou utilisez le constructeur BigInt() : BigInt('0xFFFFFFFFFFFFFFFF').toString(2) produit la chaîne binaire complète de 64 bits. Le type Number standard perd en précision au-delà de 9 007 199 254 740 991 (2⁵³ - 1). Notre convertisseur de base utilise BigInt en interne pour une précision sans limite.

Comment convertir de l’hexadécimal en binaire ?

Remplacez chaque chiffre hex par son équivalent 4 bits via la table des nibbles en sens inverse : 0=0000, 1=0001, …, A=1010, …, F=1111. Exemple : hex AF → A (1010) + F (1111) → binaire 10101111. En code : JavaScript parseInt('AF', 16).toString(2) ou Python bin(int('AF', 16))[2:].

Comment convertir un masque `/30` en notation décimale pointée ?

Un /30 correspond à 30 bits à 1 en tête, soit 11111111.11111111.11111111.11111100 en binaire, ce qui donne 255.255.255.252 en décimal. Ce masque réserve 4 adresses (2² = 4) : une adresse réseau, une broadcast et deux hôtes utilisables — parfait pour les liens point à point entre routeurs, où seules deux extrémités s’adressent. Les opérateurs français (Orange, Free Pro, SFR Business) l’utilisent couramment pour l’interconnexion BGP et les tunnels IPsec.