Conversion binaire vers octal : guide complet avec tableau, exemples et code

Conversion binaire vers octal : guide complet avec tableau, exemples et code

La conversion binaire-vers-octal est l'une des opérations les plus propres en arithmétique des systèmes numériques. Comme l'octal est en base 8 et que 8 est une puissance exacte de 2 (2³ = 8), chaque chiffre octal correspond exactement à trois bits binaires. Aucun arrondi, aucun reste, aucune division longue compliquée : seulement une substitution directe et mécanique. Cette relation a fait de l'octal une notation favorite dans l'informatique ancienne, et il reste essentiel aujourd'hui pour toute personne qui travaille avec les permissions de fichiers Unix/Linux, des bases de code héritées ou des systèmes embarqués.

Ce guide couvre toute la théorie et la pratique de la conversion binaire-vers-octal. Vous apprendrez pourquoi la conversion fonctionne, comment l'effectuer à la main, comment gérer les cas limites comme les chaînes binaires de longueur impaire, et comment écrire du code qui le fait pour vous. Essayez notre convertisseur binaire vers octal gratuit pour suivre les exemples ci-dessous.

Aperçu des systèmes numériques

Avant d'entrer dans la conversion elle-même, il est utile de comprendre les quatre systèmes numériques que les programmeurs rencontrent le plus souvent.

Binaire (base 2)

Le binaire n'utilise que deux symboles : 0 et 1. Tout ordinateur numérique repose sur la logique binaire, car les transistors fonctionnent avec deux états, activé et désactivé. Même si le binaire est le langage natif du matériel, il est verbeux pour les humains : le nombre décimal 255 nécessite huit chiffres binaires (11111111).

Octal (base 8)

L'octal utilise huit symboles : 0 à 7. Chaque chiffre octal représente exactement trois bits binaires, ce qui en fait un raccourci compact pour les données binaires. L'octal était particulièrement populaire sur les systèmes avec des mots de 12, 24 et 36 bits, où la taille de mot se divise exactement par trois.

Décimal (base 10)

Le décimal utilise dix symboles : 0 à 9. C'est le système dans lequel les humains grandissent et qu'ils utilisent au quotidien. Cependant, le décimal ne s'aligne pas proprement avec le binaire, car il n'existe pas d'entier n tel que 10 = 2^n, ce qui impose une division répétée pour convertir du décimal vers le binaire.

Hexadécimal (base 16)

L'hexadécimal utilise seize symboles : 0-9 et A-F. Chaque chiffre hex correspond exactement à quatre bits binaires (puisque 16 = 2^4). L'hex domine l'informatique moderne pour les adresses mémoire, codes couleur et l'inspection de données au niveau octet. Pour la conversion hex-vers-binaire, consultez notre guide hex vers binaire.

Pourquoi le binaire et l'octal sont directement liés

L'idée clé derrière la conversion binaire-vers-octal est un fait mathématique simple : 8 = 2³. Comme la base octale est une puissance exacte de la base binaire, chaque chiffre octal correspond à un nombre fixe de chiffres binaires, précisément trois.

Cela signifie :

• Chiffre octal 0 = binaire 000
• Chiffre octal 1 = binaire 001
• Chiffre octal 7 = binaire 111

Chaque combinaison possible de trois bits binaires (il y en a exactement 2³ = 8) correspond à l'un des huit chiffres octaux. Ce n'est ni une coïncidence ni une approximation. C'est une relation structurelle exacte entre les deux systèmes numériques.

Comparez avec le décimal : convertir du binaire en décimal demande de l'arithmétique positionnelle, car 10 n'est pas une puissance de 2. Convertir du binaire en octal ne demande que du groupement et de la substitution.

Le même principe s'applique à l'hexadécimal (16 = 2^4, donc chaque chiffre hex = 4 bits), mais pas à des bases comme 5 ou 12, qui n'ont pas de relation propre avec les puissances de deux.

La méthode de groupement par 3 bits étape par étape

Convertir du binaire en octal est un processus mécanique en trois étapes.

Étape 1 : partir de la droite et former des groupes de 3 bits

Prenez le nombre binaire et, en commençant par le bit le plus à droite (le moins significatif), divisez-le en groupes de trois.

Par exemple, le nombre binaire 110101011 :

1 | 101 | 011    (grouped from right)

Étape 2 : compléter le groupe le plus à gauche avec des zéros

Si le groupe le plus à gauche contient moins de trois bits, ajoutez des zéros à gauche pour le compléter. Cela ne change pas la valeur du nombre.

001 | 101 | 011    (padded)

Étape 3 : remplacer chaque groupe de 3 bits par son chiffre octal

Utilisez la table de conversion (fournie dans la section suivante) pour remplacer chaque groupe :

• 001 = 1
• 101 = 5
• 011 = 3

Résultat : binaire 110101011 = octal 153

C'est tout l'algorithme. Pas de division, pas d'arithmétique modulaire, pas de retenue : seulement groupement, remplissage et substitution.

Table de référence rapide 3 bits (000-111)

C'est la table de correspondance essentielle à mémoriser pour la conversion binaire-vers-octal. Elle ne contient que huit entrées :

Binaire	Octal	Décimal
000	0	0
001	1	1
010	2	2
011	3	3
100	4	4
101	5	5
110	6	6
111	7	7

Comme les chiffres octaux vont de 0 à 7, cette table est exhaustive. Une fois ces huit correspondances intégrées, vous pouvez convertir n'importe quel nombre binaire en octal à la main en quelques secondes.

Exemples détaillés

Exemple 1 : binaire court (6 bits)

Entrée binaire : 101110

Étape 1 : grouper depuis la droite : 101 | 110

Étape 2 : les deux groupes ont déjà 3 bits. Aucun remplissage nécessaire.

Étape 3 : convertir :

• 101 = 5
• 110 = 6

Résultat : octal 56 (décimal 46)

Exemple 2 : octet complet (8 bits)

Entrée binaire : 11010110

Étape 1 : grouper depuis la droite : 11 | 010 | 110

Étape 2 : compléter le groupe de gauche : 011 | 010 | 110

Étape 3 : convertir :

• 011 = 3
• 010 = 2
• 110 = 6

Résultat : octal 326 (décimal 214)

Remarquez qu'un octet (8 bits) produit toujours deux ou trois chiffres octaux, car 8 n'est pas divisible par 3. C'est l'une des raisons pour lesquelles l'hexadécimal (où un octet = exactement deux chiffres hex) est devenu plus populaire que l'octal pour les architectures orientées octets.

Exemple 3 : binaire de longueur impaire (5 bits)

Entrée binaire : 10011

Étape 1 : grouper depuis la droite : 10 | 011

Étape 2 : compléter : 010 | 011

Étape 3 : convertir :

• 010 = 2
• 011 = 3

Résultat : octal 23 (décimal 19)

Exemple 4 : binaire long (16 bits)

Entrée binaire : 1100100111010110

Étape 1 : grouper depuis la droite : 1 | 100 | 100 | 111 | 010 | 110

Étape 2 : compléter : 001 | 100 | 100 | 111 | 010 | 110

Étape 3 : convertir :

• 001 = 1
• 100 = 4
• 100 = 4
• 111 = 7
• 010 = 2
• 110 = 6

Résultat : octal 144726 (décimal 51 670)

Exemple 5 : tous les bits à 1

Entrée binaire : 111111111 (neuf bits à 1)

Étape 1 : grouper : 111 | 111 | 111

Étape 2 : aucun remplissage nécessaire (déjà aligné).

Étape 3 : convertir : 111 = 7, 111 = 7, 111 = 7

Résultat : octal 777 (décimal 511)

Cette valeur est significative dans les permissions Unix : chmod 777 accorde les permissions lecture, écriture et exécution au propriétaire, au groupe et aux autres.

Table de conversion étendue (0-127)

Le tableau suivant liste les valeurs binaires, octales et décimales pour les nombres 0 à 127. Il couvre toute la plage ASCII 7 bits et les valeurs les plus courantes.

Décimal	Binaire	Octal	Décimal	Binaire	Octal
0	000 000	00	64	1 000 000	100
1	000 001	01	65	1 000 001	101
2	000 010	02	66	1 000 010	102
3	000 011	03	67	1 000 011	103
4	000 100	04	68	1 000 100	104
5	000 101	05	69	1 000 101	105
6	000 110	06	70	1 000 110	106
7	000 111	07	71	1 000 111	107
8	001 000	10	72	1 001 000	110
9	001 001	11	73	1 001 001	111
10	001 010	12	74	1 001 010	112
11	001 011	13	75	1 001 011	113
12	001 100	14	76	1 001 100	114
13	001 101	15	77	1 001 101	115
14	001 110	16	78	1 001 110	116
15	001 111	17	79	1 001 111	117
16	010 000	20	80	1 010 000	120
17	010 001	21	81	1 010 001	121
18	010 010	22	82	1 010 010	122
19	010 011	23	83	1 010 011	123
20	010 100	24	84	1 010 100	124
21	010 101	25	85	1 010 101	125
22	010 110	26	86	1 010 110	126
23	010 111	27	87	1 010 111	127
24	011 000	30	88	1 011 000	130
25	011 001	31	89	1 011 001	131
26	011 010	32	90	1 011 010	132
27	011 011	33	91	1 011 011	133
28	011 100	34	92	1 011 100	134
29	011 101	35	93	1 011 101	135
30	011 110	36	94	1 011 110	136
31	011 111	37	95	1 011 111	137
32	100 000	40	96	1 100 000	140
33	100 001	41	97	1 100 001	141
34	100 010	42	98	1 100 010	142
35	100 011	43	99	1 100 011	143
36	100 100	44	100	1 100 100	144
37	100 101	45	101	1 100 101	145
38	100 110	46	102	1 100 110	146
39	100 111	47	103	1 100 111	147
40	101 000	50	104	1 101 000	150
41	101 001	51	105	1 101 001	151
42	101 010	52	106	1 101 010	152
43	101 011	53	107	1 101 011	153
44	101 100	54	108	1 101 100	154
45	101 101	55	109	1 101 101	155
46	101 110	56	110	1 101 110	156
47	101 111	57	111	1 101 111	157
48	110 000	60	112	1 110 000	160
49	110 001	61	113	1 110 001	161
50	110 010	62	114	1 110 010	162
51	110 011	63	115	1 110 011	163
52	110 100	64	116	1 110 100	164
53	110 101	65	117	1 110 101	165
54	110 110	66	118	1 110 110	166
55	110 111	67	119	1 110 111	167
56	111 000	70	120	1 111 000	170
57	111 001	71	121	1 111 001	171
58	111 010	72	122	1 111 010	172
59	111 011	73	123	1 111 011	173
60	111 100	74	124	1 111 100	174
61	111 101	75	125	1 111 101	175
62	111 110	76	126	1 111 110	176
63	111 111	77	127	1 111 111	177

Vous pouvez vérifier n'importe laquelle de ces valeurs avec notre convertisseur binaire vers octal.

Reconvertir l'octal en binaire

Le processus inverse, octal vers binaire, est tout aussi simple. Remplacez simplement chaque chiffre octal par son équivalent binaire sur 3 bits.

Processus inverse étape par étape

1. Écrivez le nombre octal. Retirez toute notation de préfixe (comme un 0 initial en C/C++ ou 0o en Python).
2. Remplacez chaque chiffre octal par sa valeur binaire sur 3 bits. Utilisez la même table de 8 entrées ci-dessus.
3. Concaténez les groupes. Le résultat est la représentation binaire complète.
4. Supprimez les zéros en tête (facultatif) pour obtenir la forme binaire minimale.

Exemple : octal 375 vers binaire

Entrée octale : 375

• 3 = 011
• 7 = 111
• 5 = 101

Résultat : 011111101 ou, en retirant le zéro de tête, 11111101 (décimal 253)

Exemple : octal 52 vers binaire

Entrée octale : 52

• 5 = 101
• 2 = 010

Résultat : 101010 (décimal 42)

Cette simplicité bidirectionnelle découle directement de la relation 2³ = 8. La conversion est sans perte, exacte et ne demande aucune arithmétique.

Exemples de programmation

Python

Python fournit une prise en charge intégrée de l'octal et du binaire :

# Basic binary to octal conversion
binary_str = "110101011"
decimal_value = int(binary_str, 2)
octal_str = oct(decimal_value)  # '0o653'

# Clean output (no prefix)
clean_octal = oct(decimal_value)[2:]  # '653'

# One-liner
def bin_to_oct(b):
    return oct(int(b, 2))[2:]

# Using the 3-bit grouping method manually
def bin_to_oct_manual(binary):
    # Pad to multiple of 3
    while len(binary) % 3 != 0:
        binary = '0' + binary
    # Group and convert
    octal = ''
    for i in range(0, len(binary), 3):
        group = binary[i:i+3]
        octal += str(int(group, 2))
    return octal

print(bin_to_oct_manual("110101011"))  # '653'
print(bin_to_oct_manual("11111111"))   # '377'

JavaScript

JavaScript utilise parseInt() et .toString() pour les conversions de base :

// Basic binary to octal conversion
const binary = "110101011";
const octal = parseInt(binary, 2).toString(8);  // '653'

// Function with input validation
function binaryToOctal(bin) {
  if (!/^[01]+$/.test(bin)) {
    throw new Error("Invalid binary string");
  }
  return parseInt(bin, 2).toString(8);
}

// Manual 3-bit grouping method
function binaryToOctalManual(binary) {
  // Pad to multiple of 3
  while (binary.length % 3 !== 0) {
    binary = "0" + binary;
  }
  let octal = "";
  for (let i = 0; i < binary.length; i += 3) {
    const group = binary.substring(i, i + 3);
    octal += parseInt(group, 2).toString();
  }
  return octal;
}

console.log(binaryToOctalManual("110101011"));  // '653'
console.log(binaryToOctalManual("111101101"));  // '755'

C

C demande une approche manuelle puisqu'il n'existe pas de conversion de base intégrée pour les chaînes :

#include <stdio.h>
#include <string.h>

void binaryToOctal(const char *binary) {
    int len = strlen(binary);

    // Calculate padding needed for multiple of 3
    int padding = (3 - (len % 3)) % 3;
    int totalLen = len + padding;

    // Create padded binary string
    char padded[65];
    memset(padded, '0', padding);
    strcpy(padded + padding, binary);

    // Convert each 3-bit group
    printf("Binary %s = Octal ", binary);
    for (int i = 0; i < totalLen; i += 3) {
        int value = (padded[i] - '0') * 4
                  + (padded[i+1] - '0') * 2
                  + (padded[i+2] - '0');
        printf("%d", value);
    }
    printf("\n");
}

int main() {
    binaryToOctal("110101011");   // Octal 653
    binaryToOctal("111101101");   // Octal 755
    binaryToOctal("11111111");    // Octal 377
    binaryToOctal("1");           // Octal 1
    return 0;
}

Les trois implémentations produisent des résultats identiques. La méthode manuelle par groupement reflète exactement ce que vous faites à la main, tandis que les fonctions intégrées (oct() en Python, .toString(8) en JavaScript) gèrent le groupement en interne.

Application pratique : permissions de fichiers Unix/Linux

L'usage quotidien le plus visible des nombres octaux en informatique moderne est celui des permissions de fichiers Unix/Linux. Si vous avez déjà tapé chmod 755 script.sh dans un terminal, vous avez utilisé la conversion binaire-vers-octal, que vous l'ayez remarqué ou non.

Fonctionnement des permissions Unix

Chaque fichier et répertoire dans un système de type Unix possède trois ensembles de permissions :

• Owner (utilisateur qui a créé le fichier)
• Group (utilisateurs du groupe du fichier)
• Others (tous les autres)

Chaque ensemble possède trois indicateurs de permission :

Permission	Symbole	Bit binaire	Valeur
Read	r	1	4
Write	w	1	2
Execute	x	1	1

Chaque ensemble de trois permissions correspond exactement à 3 bits binaires, qui correspondent exactement à un chiffre octal. Ce n'est pas une coïncidence : l'octal a été choisi précisément parce qu'il s'aligne parfaitement avec les groupes de permissions sur 3 bits.

Décoder chmod 755

Le nombre octal 755 se décompose ainsi :

Qui	Octal	Binaire	Permissions	Signification
Owner	7	111	rwx	Read + Write + Execute
Group	5	101	r-x	Read + Execute
Others	5	101	r-x	Read + Execute

Ainsi, chmod 755 définit le masque de permissions binaire complet à 111 101 101, accordant le contrôle complet au propriétaire tout en permettant aux autres de lire et exécuter sans modifier le fichier.

Valeurs de permissions courantes

Octal	Binaire	Symbolique	Usage typique
777	111 111 111	rwxrwxrwx	Accès complet pour tous (risqué)
755	111 101 101	rwxr-xr-x	Scripts exécutables, répertoires
750	111 101 000	rwxr-x---	Exécutables accessibles au groupe
700	111 000 000	rwx------	Exécutables privés
644	110 100 100	rw-r--r--	Fichiers ordinaires (contenu web)
600	110 000 000	rw-------	Fichiers privés (clés SSH)
400	100 000 000	r--------	Lecture seule (certificats)

Comprendre la conversion binaire-vers-octal rend les valeurs chmod intuitives plutôt que mystérieuses.

L'octal dans l'histoire de l'informatique et ses usages modernes

Importance historique

La notation octale dominait les débuts de l'informatique pour une raison pratique : de nombreux premiers ordinateurs utilisaient des tailles de mots multiples de trois. Le PDP-8 (mots de 12 bits), l'UNIVAC 1108 (mots de 36 bits) et l'IBM 7090 (mots de 36 bits) avaient tous des architectures où l'octal était la notation compacte naturelle. Un mot de 12 bits correspond proprement à quatre chiffres octaux. Un mot de 36 bits correspond à douze chiffres octaux.

Le préfixe octal 0 du langage C est un héritage direct de cette époque : Ken Thompson et Dennis Ritchie ont développé C sur un PDP-11, et la notation octale était standard aux Bell Labs. Cette convention persiste encore dans C, C++, Java et d'autres langages (par exemple, 0755 en C est l'octal 755, décimal 493).

Pourquoi l'hex a largement remplacé l'octal

Le passage de l'octal à l'hexadécimal s'est produit lorsque l'industrie s'est standardisée autour des octets de 8 bits. Comme 8 n'est pas divisible par 3, un octet ne correspond pas proprement à un nombre entier de chiffres octaux (il faut 2,67 chiffres octaux). En revanche, un octet correspond exactement à deux chiffres hex. À mesure que les architectures adressables par octet (Intel 8080, Zilog Z80, Motorola 68000) sont devenues dominantes, l'hexadécimal est devenu la notation privilégiée.

Où l'octal est encore utilisé aujourd'hui

Malgré la domination de l'hexadécimal, l'octal reste pertinent dans plusieurs domaines :

• Permissions de fichiers Unix/Linux : chmod, umask et stat utilisent l'octal
• Littéraux octaux C/C++ : tout littéral entier avec un 0 en tête (par exemple 0755) est interprété comme octal
• Littéraux octaux Python : le préfixe 0o (par exemple 0o755)
• Séquences d'échappement : certains langages utilisent \nnn (octal) pour les échappements de caractères
• Codes de transpondeur aviation : les codes squawk des avions sont des nombres octaux à quatre chiffres (0000-7777)
• Systèmes hérités : le code et la documentation mainframe des années 1960-1970 utilisent souvent l'octal

Foire aux questions

Comment convertir le binaire en octal ?

Regroupez les chiffres binaires par ensembles de trois de droite à gauche, en complétant le groupe le plus à gauche avec des zéros si nécessaire. Remplacez ensuite chaque groupe de 3 bits par son équivalent octal (000=0, 001=1, 010=2, 011=3, 100=4, 101=5, 110=6, 111=7). Par exemple, le binaire 11010110 se groupe en 011 010 110, ce qui donne l'octal 326.

Pourquoi la conversion binaire-vers-octal utilise-t-elle des groupes de 3 ?

Parce que 8 = 2³. La base octale (8) est la troisième puissance de la base binaire (2), ce qui signifie qu'exactement trois bits binaires sont nécessaires pour représenter toutes les valeurs possibles d'un chiffre octal (0 à 7). Cette relation mathématique rend la conversion directe, sans arithmétique.

Que vaut le binaire 11111111 en octal ?

Le binaire 11111111 (décimal 255) se convertit en octal 377. Groupement depuis la droite : 011 111 111, ce qui donne 3-7-7. C'est la valeur maximale d'un octet en notation octale.

Comment gérer les nombres binaires dont la longueur n'est pas un multiple de 3 ?

Complétez le groupe le plus à gauche avec des zéros. Par exemple, le binaire 10011 a 5 chiffres. Groupé depuis la droite : 10 011. Groupe gauche complété : 010 011. Conversion : 2-3. Le résultat est octal 23. Ajouter des zéros en tête ne change pas la valeur numérique.

Quelle est la différence entre octal et hexadécimal ?

L'octal est en base 8 (chiffres 0-7) et chaque chiffre représente 3 bits binaires. L'hexadécimal est en base 16 (chiffres 0-9, A-F) et chaque chiffre représente 4 bits binaires. L'hex est plus courant en informatique moderne parce qu'il s'aligne avec les octets de 8 bits (2 chiffres hex = 1 octet), tandis que l'octal reste utilisé pour les permissions de fichiers Unix et les systèmes hérités.

Pourquoi chmod utilise-t-il des nombres octaux ?

Chaque ensemble de permissions de fichier (propriétaire, groupe, autres) contient trois indicateurs binaires : lecture (r), écriture (w) et exécution (x). Trois indicateurs binaires correspondent directement à un chiffre octal (puisque 2³ = 8). Cela fait de l'octal la notation la plus naturelle et compacte pour exprimer les permissions Unix. Par exemple, rwxr-xr-x = 111 101 101 = 755 en octal.

Peut-on convertir l'octal en binaire directement ?

Oui : remplacez simplement chaque chiffre octal par son équivalent binaire sur 3 bits. L'octal 47 devient 100 111 (binaire). Le processus est l'inverse exact de la conversion binaire-vers-octal et il est tout aussi mécanique. Aucune division ni multiplication n'est nécessaire.

Que valent l'octal 777 en binaire et en décimal ?

L'octal 777 vaut le binaire 111 111 111 (neuf bits à 1) et le décimal 511. Dans les permissions Unix, chmod 777 accorde les permissions complètes lecture, écriture et exécution au propriétaire, au groupe et à tous les autres utilisateurs.

Résumé

La conversion binaire-vers-octal repose sur un fait fondamental : 8 = 2³, donc chaque chiffre octal correspond exactement à trois bits binaires. Que vous convertissiez une valeur de 3 bits ou une adresse de 64 bits, l'algorithme est toujours le même : grouper par trois depuis la droite, compléter le groupe le plus à gauche et substituer.

Points clés de ce guide :

• Regroupez les chiffres binaires en blocs de 3 bits depuis la droite et remplacez chaque groupe par son chiffre octal (000-111 correspond à 0-7)
• Complétez le groupe le plus à gauche avec des zéros si le nombre total de bits n'est pas un multiple de trois
• Les permissions de fichiers Unix sont l'usage moderne le plus courant de l'octal, chaque triplet rwx correspondant à un chiffre octal
• Les langages de programmation fournissent des conversions intégrées : oct(int(x, 2)) en Python, parseInt(x, 2).toString(8) en JavaScript, et groupement manuel en C
• La conversion inverse (octal vers binaire) remplace chaque chiffre octal par sa valeur binaire sur 3 bits
• L'octal dominait historiquement sur les systèmes dont les tailles de mots étaient divisibles par 3, mais l'hexadécimal a pris le relais avec la standardisation des octets de 8 bits

Prêt à pratiquer ? Utilisez notre convertisseur binaire vers octal gratuit pour convertir instantanément n'importe quelle valeur binaire en octal, avec visualisation étape par étape des groupes de 3 bits et remplissage automatique.