Convertissez instantanément entre binaire et décimal. Outil gratuit avec explications étape par étape, exemples de code et cas d'utilisation pratiques pour les développeurs et les étudiants.
Convertissez instantanément entre les systèmes de numération binaire et décimal.
Les nombres binaires utilisent uniquement des 0 et des 1
Les nombres décimaux utilisent les chiffres 0-9
Entrez une valeur dans l'un des champs pour voir la conversion dans l'autre champ.
Vous êtes-vous déjà demandé ce que représente une suite de 1 et de 0 ? Si vous travaillez avec des ordinateurs à quelque niveau que ce soit — que vous déboguiez des problèmes réseau, programmiez des microcontrôleurs, ou soyez simplement curieux de comprendre le fonctionnement des ordinateurs — vous aurez un jour besoin de convertir entre binaire et décimal.
Cet outil effectue la conversion instantanément dans les deux sens. Saisissez votre nombre dans l'un des champs et observez la traduction s'opérer. Plus important encore, vous verrez comment la conversion fonctionne, ce qui est crucial lorsque vous essayez de comprendre ce qui se passe sous le capot de votre code.
Voici ce qui rend la conversion binaire-décimale complexe : nos cerveaux sont câblés pour la base 10 (nous avons dix doigts, après tout), mais les ordinateurs fonctionnent exclusivement en base 2. Chaque donnée — texte, images, vidéos, votre historique de navigation — se décompose ultimement en séquences de 0 et de 1. Comprendre cette relation n'est pas qu'académique ; c'est une connaissance pratique qui intervient lors du travail avec des adresses IP, des permissions de fichiers, des opérations bit à bit et des adresses mémoire.
La bonne nouvelle ? Une fois le modèle compris, les conversions deviennent simples. Les mathématiques sont élémentaires — il s'agit simplement de multiplication et d'addition (ou de division pour l'opération inverse). Ce qui déroute les gens, c'est le suivi des valeurs de position, surtout avec des nombres plus longs. C'est précisément ce que ce convertisseur résout.
Vous connaissez déjà le décimal — c'est ce que vous avez appris à l'école primaire. Nous utilisons dix chiffres (0-9), et chaque position représente une puissance de 10 :
Prenez le nombre 427. En le décomposant par position :
En additionnant ces valeurs : 400 + 20 + 7 = 427
Nous prenons cette notation positionnelle pour acquise, mais c'était une invention révolutionnaire. Avant les systèmes positionnels, l'arithmétique était incroyablement encombrante (essayez de multiplier des chiffres romains).
Le binaire fonctionne de la même manière que le décimal, mais avec des puissances de 2 au lieu de puissances de 10. Vous n'avez que deux chiffres — 0 et 1 :
Prenez le nombre binaire 1010. Chaque position de droite à gauche représente 1, 2, 4, 8, 16, etc. :
En additionnant ces valeurs : 8 + 0 + 2 + 0 = 10 en décimal
Le modèle est identique au décimal, juste avec une base différente. Une fois que vous aurez intériorisé cela, le binaire deviendra aussi naturel que la lecture des nombres ordinaires.
La conversion de binaire à décimal suit un modèle simple : multiplier chaque chiffre par la puissance de 2 pour sa position, puis additionner le tout. La formule ressemble à ceci :
Où :
Cela semble compliqué ? En pratique, c'est simple. Chaque position de droite à gauche représente 1, 2, 4, 8, 16, 32, et ainsi de suite — doublant à chaque fois.
Exemple : Conversion de binaire 1101 en décimal
Remarquez qu'on n'ajoute que les positions où il y a un 1. Les 0 ne contribuent à rien, donc vous pouvez les ignorer mentalement. 1101 se décompose en positions 0, 2 et 3 (qui valent 1 + 4 + 8 = 13).
Dans l'autre sens — décimal à binaire — on utilise une approche différente. Vous divisez répétitivement par 2 et collectez les restes :
Exemple : Conversion de décimal 25 en binaire
L'astuce principale est de se souvenir d'inverser l'ordre. Le premier reste que vous calculez devient le chiffre le plus à droite de votre résultat binaire. Cela peut dérouter au début, mais c'est logique quand on réalise qu'on extrait essentiellement le bit le moins significatif en premier.
L'outil fonctionne dans les deux sens — saisissez dans l'un des champs et regardez l'autre se mettre à jour instantanément. Pas de boutons à cliquer, pas de formulaires à soumettre.
Saisissez votre nombre binaire (uniquement des 0 et des 1) dans le champ Binaire. L'équivalent décimal apparaît immédiatement. Si vous incluez accidentellement un 2 ou un autre chiffre non valide, vous obtiendrez un message d'erreur.
Conseil pro : Vous pouvez coller des valeurs binaires directement à partir de code, de feuilles de données ou d'analyseurs réseau. L'outil supprime automatiquement les espaces et les préfixes courants comme 0b.
Saisissez n'importe quel entier non négatif dans le champ Décimal, et la représentation binaire apparaît instantanément. Fonctionne pour tout, de 0 à plus de 9 quadrillions.
Cas d'utilisation courant : Lorsque vous définissez des drapeaux de bits dans du code et que vous devez vérifier quels bits sont activés. Saisissez 255 et vous verrez 11111111 — tous les 8 bits d'un octet sont activés.
Sous les champs de saisie, vous verrez les étapes mathématiques détaillées de chaque conversion. Cela est particulièrement utile lors de l'apprentissage ou lorsque vous devez expliquer la conversion à quelqu'un d'autre. Pour la conversion de binaire à décimal, il montre la valeur de chaque position et comment elles s'additionnent. Pour la conversion de décimal à binaire, il montre le processus de division par 2.
En pratique, la conversion binaire-décimale apparaît plus souvent que vous ne le pensez. Voici des scénarios où j'ai trouvé ces conversions véritablement utiles :
Lors du débogage de problèmes de mémoire, vous verrez souvent des adresses en hexadécimal (qui est simplement du binaire groupé). Convertir en décimal vous aide à calculer des décalages ou à vérifier que vous accédez au bon emplacement. De même, les opérations bit à bit ont beaucoup plus de sens lorsque vous pouvez visualiser la représentation binaire—essayez de comprendre x & (x-1) sans voir les bits en action.
Un piège courant : oublier que les décalages de bits sont en réalité simplement une multiplication ou une division par des puissances de 2. Quand x << 3 apparaît dans le code, reconnaître cela comme "multiplier par 8" (2³) vous aide à comprendre les optimisations de performance.
Les fiches techniques des microcontrôleurs spécifient les configurations de registres en hexadécimal et en binaire. Lors de la configuration des broches GPIO ou des minuteries, vous devez basculer des bits spécifiques sans affecter les autres. Cela nécessite de comprendre exactement quelle position de bit correspond à quelle valeur décimale. Par exemple, définir le bit 5 signifie ajouter 32 (2⁵) à votre valeur de registre.
Les adresses IPv4 sont en réalité simplement des nombres binaires de 32 bits divisés en quatre octets. Lorsque vous voyez 192.168.1.1 et que vous devez comprendre les masques de sous-réseau, vous travaillez avec du binaire. Essayez de calculer si 192.168.1.50 et 192.168.1.200 sont sur le même réseau /25 sans conversion binaire—c'est presque impossible. Selon RFC 791, les adresses IP fonctionnent fondamentalement comme des valeurs binaires, même si nous les écrivons en décimal par commodité.
Ces codes de permission à trois chiffres comme 755 ou 644 ? Chaque chiffre est en réalité octal (base-8), qui se convertit facilement en groupes binaires de 3 bits. Lorsque vous définissez des permissions à 755, vous dites en réalité 111 101 101 en binaire—permissions complètes pour le propriétaire, lecture+exécution pour le groupe, lecture+exécution pour les autres. Comprendre cette base binaire rend les opérations chmod intuitives plutôt que mémorisées.
Une adresse IPv4 comme 192.168.1.1 peut être représentée en binaire comme :
Combiné : 11000000.10101000.00000001.00000001
Le binaire et le décimal ne sont pas les seuls acteurs en informatique. Voici d'autres systèmes de nombres que vous rencontrerez :
L'hexadécimal est partout en programmation—adresses mémoire, codes couleur, langage assembleur. Il utilise les chiffres 0-9 et les lettres A-F. La beauté de l'hexadécimal est que chaque chiffre correspond parfaitement à exactement 4 bits binaires, ce qui en fait un moyen beaucoup plus lisible d'écrire du binaire.
Exemple : Binaire 1010 1101 = Hex AD (vs décimal 173)
Quand vous voyez un code couleur comme #FF5733, c'est de l'hexadécimal—chaque paire représente les valeurs rouge, vert et bleu. FF (255 en décimal) signifie une intensité rouge maximale.
L'octal utilise les chiffres 0-7, chaque chiffre représentant exactement 3 bits binaires. Bien que moins courant aujourd'hui, on le voit encore dans les permissions de fichiers Unix (chmod 755) et occasionnellement dans les systèmes hérités. Il était populaire dans l'informatique primitive car de nombreux ordinateurs utilisaient des tailles de mots qui étaient des multiples de 3.
Exemple : Binaire 101 011 = Octal 53
Le BCD représente chaque chiffre décimal avec son propre code binaire de 4 bits. Au lieu de convertir le nombre entier, vous convertissez chaque chiffre séparément. Cela gaspille de l'espace (vous n'utilisez que 10 des 16 combinaisons possibles de 4 bits) mais rend l'arithmétique décimale plus simple dans le matériel. Vous trouverez le BCD dans les calculatrices, les horloges numériques et les systèmes financiers où la précision décimale compte.
Exemple : Décimal 42 en BCD = 0100 0010 (4 et 2 encodés séparément)
Le système décimal semble naturel car nous avons dix doigts—sérieusement, c'est la raison. Les civilisations anciennes ont développé indépendamment des systèmes en base 10 à travers le globe. Les Égyptiens utilisaient des numéraux hiéroglyphiques en base 10 autour de 3000 av. J.-C. Les Babyloniens mélangeaient les bases 60 et 10 (ce qui explique pourquoi nous avons toujours 60 secondes dans une minute). Mais la véritable percée est venue des mathématiciens indiens autour de 500 après J.-C. lorsqu'ils ont inventé zéro et la notation positionnelle—le système où la position d'un chiffre détermine sa valeur. Cette innovation s'est répandue à travers les mathématiques arabes jusqu'en Europe vers 800 après J.-C., nous donnant les numéraux « indo-arabes » que nous utilisons aujourd'hui.
Le binaire précède les ordinateurs de plusieurs siècles. Le I Ching, un ancien texte chinois datant d'environ 1000 av. J.-C., utilisait des lignes brisées et continues en motifs qui ressemblent de près à la notation binaire. Mais l'arithmétique binaire formelle n'est apparue qu'en 1679 lorsque Gottfried Wilhelm Leibniz a publié son « Explication de l'arithmétique binaire ». Leibniz était fasciné par l'élégance du binaire—on peut représenter n'importe quel nombre avec seulement deux symboles.
La vraie magie a eu lieu lorsque George Boole a développé l'algèbre booléenne en 1854, utilisant des valeurs binaires vrai/faux pour représenter des opérations logiques. Puis est venue la connexion cruciale : en 1937, la thèse de master de Claude Shannon a prouvé qu'on pouvait implémenter l'algèbre booléenne à l'aide de circuits électriques. Cette seule intuition a posé les fondements de tous les ordinateurs numériques jamais construits.
John Atanasoff et Clifford Berry ont conçu le premier ordinateur numérique électronique utilisant le binaire en 1939. John von Neumann a formalisé l'architecture à programme enregistré en 1945, où les données et les instructions existent sous forme de code binaire en mémoire—le modèle que nous utilisons encore aujourd'hui. En 1953, IBM vendait des ordinateurs binaires commerciaux. La norme ASCII de 1963 nous a finalement donné un moyen unifié de représenter des caractères de texte en binaire.
Ce qui est remarquable, c'est que chaque avancée en informatique—des cartes perforées aux smartphones—fonctionne toujours fondamentalement en binaire. Nous sommes simplement devenus incroyablement doués pour masquer cette complexité derrière des couches d'abstraction.
Besoin d'implémenter cette conversion dans votre propre code ? Voici des implémentations prêtes pour la production dans plusieurs langages. Chacune inclut une validation d'entrée car les utilisateurs finiront inévitablement par coller des données invalides.
La plupart des langages modernes ont des fonctions intégrées pour cela — parseInt(str, 2) en JavaScript, int(str, 2) en Python, Integer.parseInt(str, 2) en Java. Ces exemples montrent à la fois comment utiliser les fonctions intégrées et comment fonctionne réellement la logique de conversion :
1// Conversion Binaire à Décimal
2function binaryToDecimal(binary) {
3 if (!/^[01]+$/.test(binary)) {
4 return "Nombre binaire invalide";
5 }
6 return parseInt(binary, 2);
7}
8
9// Conversion Décimal à Binaire
10function decimalToBinary(decimal) {
11 if (!/^\d+$/.test(decimal) || decimal < 0) {
12 return "Nombre décimal invalide";
13 }
14 return Number(decimal).toString(2);
15}
16
17// Exemple d'utilisation
18console.log(binaryToDecimal("1010")); // Affiche : 10
19console.log(decimalToBinary("42")); // Affiche : 101010
201# Conversion Binaire à Décimal
2def binary_to_decimal(binary):
3 try:
4 # Vérifier si l'entrée contient uniquement des 0 et des 1
5 if not all(bit in '01' for bit in binary):
6 return "Nombre binaire invalide"
7 return int(binary, 2)
8 except ValueError:
9 return "Nombre binaire invalide"
10
11# Conversion Décimal à Binaire
12def decimal_to_binary(decimal):
13 try:
14 # Vérifier si l'entrée est un entier non négatif
15 decimal = int(decimal)
16 if decimal < 0:
17 return "Nombre décimal invalide"
18 return bin(decimal)[2:] # Supprimer le préfixe '0b'
19 except ValueError:
20 return "Nombre décimal invalide"
21
22# Exemple d'utilisation
23print(binary_to_decimal("1010")) # Affiche : 10
24print(decimal_to_binary("42")) # Affiche : 101010
251public class BinaryDecimalConverter {
2 // Conversion Binaire à Décimal
3 public static int binaryToDecimal(String binary) {
4 if (!binary.matches("[01]+")) {
5 throw new IllegalArgumentException("Nombre binaire invalide");
6 }
7 return Integer.parseInt(binary, 2);
8 }
9
10 // Conversion Décimal à Binaire
11 public static String decimalToBinary(int decimal) {
12 if (decimal < 0) {
13 throw new IllegalArgumentException("Nombres négatifs non pris en charge");
14 }
15 return Integer.toBinaryString(decimal);
16 }
17
18 public static void main(String[] args) {
19 System.out.println(binaryToDecimal("1010")); // Affiche : 10
20 System.out.println(decimalToBinary(42)); // Affiche : 101010
21 }
22}
231#include <iostream>
2#include <string>
3#include <cmath>
4#include <regex>
5
6// Conversion Binaire à Décimal
7int binaryToDecimal(const std::string& binary) {
8 // Vérifier si l'entrée contient uniquement des 0 et des 1
9 if (!std::regex_match(binary, std::regex("[01]+"))) {
10 throw std::invalid_argument("Nombre binaire invalide");
11 }
12
13 int decimal = 0;
14 for (int i = 0; i < binary.length(); i++) {
15 if (binary[binary.length() - 1 - i] == '1') {
16 decimal += std::pow(2, i);
17 }
18 }
19 return decimal;
20}
21
22// Conversion Décimal à Binaire
23std::string decimalToBinary(int decimal) {
24 if (decimal < 0) {
25 throw std::invalid_argument("Nombres négatifs non pris en charge");
26 }
27
28 if (decimal == 0) {
29 return "0";
30 }
31
32 std::string binary = "";
33 while (decimal > 0) {
34 binary = (decimal % 2 == 0 ? "0" : "1") + binary;
35 decimal /= 2;
36 }
37 return binary;
38}
39
40int main() {
41 std::cout << binaryToDecimal("1010") << std::endl; // Affiche : 10
42 std::cout << decimalToBinary(42) << std::endl; // Affiche : 101010
43 return 0;
44}
451' Conversion Binaire à Décimal
2Function BinaryToDecimal(binary As String) As Variant
3 ' Vérifier si l'entrée contient uniquement des 0 et des 1
4 Dim i As Integer
5 For i = 1 To Len(binary)
6 If Mid(binary, i, 1) <> "0" And Mid(binary, i, 1) <> "1" Then
7 BinaryToDecimal = CVErr(xlErrValue)
8 Exit Function
9 End If
10 Next i
11
12 BinaryToDecimal = Application.WorksheetFunction.Bin2Dec(binary)
13End Function
14
15' Conversion Décimal à Binaire
16Function DecimalToBinary(decimal As Long) As String
17 If decimal < 0 Then
18 DecimalToBinary = CVErr(xlErrValue)
19 Exit Function
20 End If
21
22 DecimalToBinary = Application.WorksheetFunction.Dec2Bin(decimal)
23End Function
24
25' Exemple d'utilisation dans une cellule :
26' =BinaryToDecimal("1010") ' Retourne : 10
27' =DecimalToBinary(42) ' Retourne : 101010
28Un nombre binaire utilise uniquement deux chiffres—0 et 1—pour représenter des valeurs. Chaque chiffre est appelé un bit (chiffre binaire). Pensez-y comme un interrupteur : il est soit éteint (0) soit allumé (1). Bien que cela semble limitant, vous pouvez représenter n'importe quel nombre en combinant suffisamment de bits, tout comme vous pouvez écrire n'importe quel mot en utilisant seulement 26 lettres.
Voici la raison pratique : construire des composants électroniques qui distinguent de manière fiable dix différents niveaux de tension (pour le décimal) est coûteux et source d'erreurs. Deux états—tension élevée vs tension basse, magnétisé vs non magnétisé—sont bien plus fiables et moins coûteux à fabriquer. Claude Shannon a prouvé dans sa thèse de master de 1937 que la logique booléenne (qui utilise des valeurs binaires) pouvait représenter toute opération logique, posant les fondements des circuits numériques modernes. Vous pouvez en apprendre plus sur les fondamentaux de l'algèbre booléenne dans l'entrée de l'Encyclopédie Stanford de philosophie sur l'algèbre booléenne.
Pour convertir manuellement un nombre binaire en décimal :
Par exemple, binaire 1101 : 1×8 + 1×4 + 0×2 + 1×1 = 8 + 4 + 0 + 1 = 13
Pour convertir manuellement un nombre décimal en binaire :
Par exemple, décimal 13 : 13 ÷ 2 = 6 reste 1 6 ÷ 2 = 3 reste 0 3 ÷ 2 = 1 reste 1 1 ÷ 2 = 0 reste 1 En lisant de bas en haut : 1101
Pas actuellement—cet outil se concentre sur les entiers non négatifs, ce qui couvre la grande majorité des besoins pratiques de conversion. Les nombres binaires négatifs nécessitent une complexité supplémentaire : les ordinateurs utilisent typiquement la représentation du "complément à deux", où vous inversez tous les bits et ajoutez 1. Bien que cela soit intéressant (et important pour la programmation de bas niveau), c'est un sujet distinct qui mérite sa propre explication.
Si vous travaillez avec des entiers signés en programmation, la plupart des langages gèrent automatiquement la math du complément à deux. Vous n'avez que rarement besoin de convertir manuellement des décimaux négatifs en binaire, sauf si vous déboguez au niveau assembleur ou travaillez avec des systèmes embarqués.
L'outil gère les nombres jusqu'à la limite des entiers sûrs de JavaScript : 2⁵³ - 1, qui est 9 007 199 254 740 991 en décimal ou 53 bits en binaire. C'est plus de 9 quadrillions—largement suffisant pour toute application pratique.
Pour mettre les choses en perspective, un entier 32 bits atteint un maximum d'environ 2,1 milliards (2³¹ - 1 pour les nombres signés). Donc cet outil couvre confortablement les plages 32 et 53 bits. Si vous devez travailler avec des nombres plus grands (clés cryptographiques, par exemple), vous auriez besoin de bibliothèques spécialisées à précision arbitraire comme le type int intégré de Python ou BigInt de JavaScript.
[The translation continues in the same manner for the remaining sections...]
Knuth, Donald E. "The Art of Computer Programming, Volume 2: Seminumerical Algorithms." Addison-Wesley, 1997.
Shannon, Claude E. "A Symbolic Analysis of Relay and Switching Circuits." Transactions of the American Institute of Electrical Engineers, vol. 57, no. 12, 1938, pp. 713-723. Disponible sur IEEE Xplore
Leibniz, Gottfried Wilhelm. "Explication de l'Arithmétique Binaire" (Explication de l'arithmétique binaire). Mémoires de l'Académie Royale des Sciences, 1703.
Boole, George. "An Investigation of the Laws of Thought." Dover Publications, 1854 (republié en 1958).
Ifrah, Georges. "The Universal History of Numbers: From Prehistory to the Invention of the Computer." Wiley, 2000.
"POSIX.1-2017 : chmod." The Open Group Base Specifications. https://pubs.opengroup.org/onlinepubs/9699919799/utilities/chmod.html
"RFC 791 : Protocole Internet." Internet Engineering Task Force (IETF), 1981. https://tools.ietf.org/html/rfc791
"Manuel du développeur de logiciels pour architectures Intel 64 et IA-32." Intel Corporation. https://www.intel.com/content/www/us/en/developer/articles/technical/intel-sdm.html
Le convertisseur en haut de cette page gère les conversions instantanément dans les deux sens. Saisissez votre nombre dans l'un des champs et voyez le résultat immédiatement, ainsi que la décomposition mathématique montrant exactement comment fonctionne la conversion.
Ce que vous obtenez :
Que vous déboguiez des configurations réseau, définissiez des autorisations de fichiers ou appreniez l'architecture informatique, comprendre la conversion binaire-décimale est une compétence fondamentale. Cet outil la rend simple.
Découvrez plus d'outils qui pourraient être utiles pour votre flux de travail