Convertisseur Binaire Décimal & Calcul

Convertisseur Binaire Décimal & Calcul

Convertissez du binaire en décimal avec notre calculateur de haute précision. Prise en charge du complément à deux signé, des bits fractionnaires et du calcul pas à pas.

Scénarios prédéfinis :
Panneau de contrôle & Entrée binaire
8 bits

Synchronisation bidirectionnelle : la modification du décimal recalcule instantanément le flux binaire.

Barre d'opérations bit à bit
Valeur décimale (Active)-8
Complément à deux-8
Hexadécimal (0x)0xF8
Architecture active8 bits
Spectre des poids positionnels & Courbe de puissance5 Bits actifs (1s)
0123456797%Décimales
Jauge d'accumulation du registre97.25%
Décimal (Base 10)
Hexadécimal (Base 16)0xF8
Octal (0o)0o370
Aperçu ASCII / UTF-8·
Aperçu BCD (Décimal codé binaire)0010 0100 1000
Encodage Base64—
Hub de syntaxe de code pour développeursExportez directement les valeurs sous forme de littéraux typés prêts pour votre code source.
Métrique principale8 bits (8 total)
Efficacité & Capacité5 / 8 (62.5%)
Résultat net-8

Traitement côté client

Calcul haute performance exécuté intégralement dans la mémoire du navigateur.

Zéro transfert vers un serveur

Toutes les données restent strictement locales, sans aucune transmission externe.

Export prêt pour la production

Formats de sortie propres et optimisés, prêts pour un déploiement immédiat.

ToolsAA•Utilitaires web 100% privés côté client
Référence technique et guide d'architecture

Convertisseur Binaire en Décimal — Guide de référence

Convertissez des nombres binaires en décimal avec notre calculateur haute précision. Prise en charge du complément à deux signé, des bits fractionnaires et du détail des calculs.

Convertisseur Binaire en Décimal — Guide de référence — Architecture en mémoire côté client et flux de données
Convertisseur Binaire en Décimal — Guide de référence — Architecture en mémoire côté client et flux de données

Paramètres clés et contrôles

Séquence binaire positionnelleSéquence positionnelle en base 2 ({0, 1})

Suite continue de chiffres binaires évaluée par accumulation polynomiale de Horner en O(n), représentant les puissances de 2 du MSB vers le LSB. Prend en charge les virgules fractionnaires selon IEEE 754, les préfixes standard « 0b » et les délimiteurs visuels.

Par défaut : 11010110
Largeur de mot registreLimite de mot d'architecture (8 | 16 | 32 | 64 | BigInt)

Limite de registre du processeur cible fixant les seuils de dépassement arithmétique (overflow), l'emplacement du bit de signe et les contraintes d'extension de zéros. Les valeurs dépassant 53 bits basculent automatiquement vers un BigInt en précision arbitraire afin d'éviter la troncature de la mantisse selon IEEE 754.

Par défaut : 8 bits (Octet : -128 à 127 signé / 0 à 255 non signé)
Encodage du signe entierNorme d'entier binaire (Non signé | Complément à deux | Complément à un | Signe et valeur absolue)

Convention mathématique régissant l'interprétation des valeurs négatives. Le complément à deux affecte un poids négatif -2^(n-1) au MSB ; le mode non signé traite tous les bits comme des grandeurs positives ou nulles jusqu'à 2^n - 1 ; le mode signe et valeur absolue réserve le bit n-1 exclusivement à la polarité.

Par défaut : Complément à deux (signé)
Bits fractionnaires de baseMantisse binaire en virgule fixe (b_{-1} * 2^-1 + b_{-2} * 2^-2 ...)

Bits fractionnaires situés à droite de la virgule binaire, évalués comme des exposants entiers négatifs de base 2 (0,5 ; 0,25 ; 0,125 ; 0,0625, etc.). Les fractions rationnelles non périodiques finies sont limitées à la profondeur de mantisse du registre cible.

Par défaut : 0.1011 (0,6875 en décimal)
Ordre des octets en mémoire (Boutisme)Séquence d'octets en mémoire (Big-Endian MSB | Little-Endian LSB)

Sérialisation séquentielle des octets dans les mots binaires multi-octets. Le format Big-Endian (Network Byte Order selon la RFC 791) place le MSB à l'adresse de décalage 0, tandis que le format Little-Endian (x86-64 / ARM NEON) stocke le LSB en tête, imposant une permutation d'octets (byte-swap) lors de l'inspection de paquets réseau.

Par défaut : Big-Endian (positionnel standard)
Format de regroupement visuelDélimiteur d'affichage visuel (Quartet de 4 bits | Octet de 8 bits | Aucun)

Configuration d'espacement regroupant les chiffres binaires en quartets lisibles de 4 bits (nibbles) ou en octets de 8 bits afin de faciliter le contrôle visuel de parité et d'éviter les erreurs de transcription manuelle sans altérer les valeurs mathématiques.

Par défaut : Espacement par quartets de 4 bits

Conseils de pro et bonnes pratiques

Asymétrie de plage du complément à deux et dépassement critique

Dans un système en complément à deux sur n bits, les valeurs s'étendent sur un intervalle asymétrique de -2^(n-1) à +2^(n-1) - 1 (par exemple, -128 à +127 sur 8 bits, ou -2 147 483 648 à +2 147 483 647 sur 32 bits). Comme le zéro (00000000) occupe une place dans l'espace des entiers positifs ou nuls, la valeur la plus négative (-2^(n-1)) n'a aucun équivalent positif. Tenter d'inverser le signe de -128 ou d'évaluer abs(-128) dans un registre signé de 8 bits provoque un dépassement arithmétique (overflow) immédiat ou boucle sur -128 par rebouclage cyclique (wrap-around). Les compilateurs et les bibliothèques cryptographiques (comme l'arithmétique modulaire en temps constant dans l'API Web Crypto) parent ce piège en appliquant une extension de signe vers un mot plus large (par exemple de int8_t vers int16_t) avant toute inversion mathématique.

Inexactitude des flottants binaires face aux fractions décimales en base 10

Une fraction admet un développement fini dans une base donnée si et seulement si tous les facteurs premiers de son dénominateur irréductible divisent cette base. En binaire (base 2), l'unique facteur premier est 2. Par conséquent, les fractions décimales élémentaires dont le dénominateur comporte le facteur 5 (telles que 0,1 = 1/(2×5) ou 0,2 = 1/5) produisent un développement binaire périodique infini : 0,0001100110011..._2. Stockée dans un registre à virgule flottante IEEE 754 64 bits, la mantisse est tronquée à 53 bits, générant une erreur d'arrondi intrinsèque de 0,1000000000000000055511151231257827021181583404541015625. Les calculs financiers et cryptographiques ne doivent jamais s'appuyer sur des flottants binaires : utilisez une mise à l'échelle rationnelle exacte (BigInt pour le numérateur et le dénominateur) ou des représentations DCB (décimal codé binaire / BCD) en virgule fixe.

Décalage arithmétique vs décalage logique pour les entiers négatifs signés

Lors de la division d'entiers binaires signés par des puissances de 2 au moyen de décalages de bits, l'appel d'un décalage logique à droite (>>> en JavaScript, SHR en assembleur x86) injecte des bits 0 dans le MSB, ce qui corrompt le bit de signe et métamorphose instantanément un entier négatif en une gigantesque valeur non signée (par exemple, -8 >>> 1 renvoie 2 147 483 644 dans l'espace 32 bits). À l'inverse, un décalage arithmétique à droite (>> en C/Java/JS, SAR en assembleur x86) réplique le MSB sur les positions libérées (extension de signe). Notez qu'un décalage arithmétique arrondit vers l'infini négatif (floor(N / 2^k)), si bien que -7 >> 1 donne -4, tandis que la division entière décimale standard tronque vers zéro (-7 / 2 = -3).

Permutation du boutisme multi-octets entre réseau et architecture processeur

Les normes de l'IETF (RFC 791 IPv4, RFC 2460 IPv6, TCP/UDP) imposent l'ordre des octets réseau (Network Byte Order), qui est rigoureusement Big-Endian (le MSB réside à l'adresse mémoire la plus basse). À l'inverse, les environnements d'exécution modernes (x86-64, ARM Apple Silicon) fonctionnent nativement en Little-Endian (le LSB à l'adresse la plus basse). Désérialiser une chaîne binaire de port 16 bits '00000001 10111011' (443 en décimal pour le protocole HTTPS) directement dans un registre hôte sans utiliser de fonctions de permutation d'octets (telles que ntohs() ou DataView.prototype.getUint16(offset, false)) inverse les octets en '10111011 00000001', ce qui équivaut à 47 873 en décimal et entraîne l'échec immédiat de la connexion réseau.

Schéma de Horner linéaire en O(n) vs exponentiation naïve dans le navigateur

Les implémentations élémentaires de conversion binaire en décimal calculent la valeur de chaque bit par des élévations de puissances individuelles (somme des b_i × 2^i), engendrant O(n^2) opérations sur les bits pour une chaîne de n bits et saturant le moteur JavaScript mono-thread du navigateur lors du traitement de gros flux de données (comme des clés cryptographiques RSA de 4096 bits). L'algorithme optimal s'appuie sur la méthode de Horner : initialiser un accumulateur à 0, puis parcourir les bits du MSB au LSB en exécutant accumulateur = (accumulateur << 1) | bit en une passe unique en O(n). Dans un bac à sable côté client, combiner cette accumulation bit à bit en O(n) avec le type natif BigInt assure une exécution en moins d'une milliseconde sans bloquer la boucle d'événements (event loop) ni transmettre la moindre donnée binaire confidentielle sur le réseau.

Pièges courants et dépannage

⚠️Inversion involontaire du signe due à la suppression des zéros initiaux

Dans l'évaluation en complément à deux signé, le bit de poids fort (MSB) fait office de bit de signe. Si vous entrez un entier positif de 8 bits comme 01111111 (+127) et qu'un parseur supprime automatiquement le zéro non significatif, la chaîne se réduit à 7 bits : 1111111. Interprété dans un format signé de 7 bits, le 1 le plus à gauche devient le bit de signe, convertissant à tort +127 en -1 (-64 + 32 + 16 + 8 + 4 + 2 + 1 = -1). Solution : Déclarez explicitement la largeur de mot cible (8, 16, 32 ou 64 bits) afin d'imposer un remplissage par des zéros (zero-padding), garantissant la préservation des zéros initiaux comme délimiteurs de polarité positive.

⚠️Dépassement de la limite de précision des entiers sûrs de 53 bits en JavaScript

Les nombres natifs Number d'ECMAScript répondent à la norme flottante double précision IEEE 754, qui n'octroie que 52 bits pour la fraction plus 1 bit implicite. Convertir des chaînes binaires de plus de 53 bits (telles que des adresses mémoire 64 bits ou des blocs d'état SHA-256) avec parseInt(str, 2) provoque une altération silencieuse des bits, arrondissant les bits de poids faible au-delà de Number.MAX_SAFE_INTEGER (9 007 199 254 740 991 ou 2^53 - 1). Solution : Convertissez les séquences binaires excédant 53 bits directement en BigInt natif à l'aide de BigInt('0b' + cleanBinaryStr) ou par accumulation de Horner avec BigInt, préservant l'intégralité des bits sans aucune perte de mantisse.

⚠️Divergence décimale des fractions binaires périodiques infinies

Lors de la conversion de fractions rationnelles décimales en binaire en virgule fixe, les fractions dont le dénominateur contient d'autres facteurs premiers que des puissances de 2 génèrent des séquences binaires périodiques infinies (par exemple 0,3333... ou 0,1 en décimal). Tenter de calculer la valeur décimale exacte d'une fraction binaire arbitrairement tronquée sans borner les termes rationnels conduit à des écarts de calcul visibles. Solution : Fixez une limite de précision fractionnaire stricte (ex. 32 ou 64 bits de mantisse) et adoptez une arithmétique de fractions rationnelles (couples de BigInt numérateur / dénominateur P/Q) conjuguée à la règle d'arrondi au pair le plus proche selon IEEE 754 pour garantir une équivalence mathématique absolue.

⚠️Présence de préfixes de base ou de délimiteurs parasites dans la saisie binaire

Le collage de chaînes binaires brutes issues de désassembleurs, de captures de paquets Wireshark ou d'afficheurs de mémoire insère régulièrement des préfixes ('0b', '0B'), des séquences d'échappement hexadécimales, des délimiteurs d'octets (espaces, traits d'union, tirets bas, deux-points) ou des sauts de ligne. Les fonctions de conversion classiques rejettent ces caractères invalides avec NaN ou une erreur de syntaxe. Solution : Nettoyez l'entrée à l'aide d'une regex déterministe (`s.replace(/^0b/i, '').replace(/[^01.]/g, '')`) pour supprimer les artefacts lexicaux et valider l'unicité de la virgule binaire en temps O(n) avant la conversion numérique.

Foire aux questions (FAQ)

Comment convertir un nombre binaire en décimal étape par étape ?▼

Pour convertir un nombre binaire en décimal, multipliez chaque chiffre binaire (bit) par 2 élevé à la puissance de son rang positionnel (en démarrant à 0 pour le LSB situé tout à droite), puis faites la somme des produits : Décimal = ∑ (b_i × 2^i). Par exemple, pour convertir le binaire 11010110_2 en décimal : (1 × 2^7) + (1 × 2^6) + (0 × 2^5) + (1 × 2^4) + (0 × 2^3) + (1 × 2^2) + (1 × 2^1) + (0 × 2^0) = 128 + 64 + 0 + 16 + 0 + 4 + 2 + 0 = 214 en base 10 décimale. La méthode polynomiale de Horner permet également de calculer ce résultat de gauche à droite en temps linéaire O(n) : partez d'un accumulateur initialisé à 0, puis pour chaque bit, multipliez l'accumulateur par 2 et ajoutez le bit.

Comment le complément à deux représente-t-il les nombres binaires négatifs en décimal ?▼

Dans la notation en complément à deux, le bit de poids fort (MSB) possède un poids positionnel négatif égal à -2^(n-1), tandis que les n-1 autres bits conservent des poids positionnels positifs : Décimal = (-b_{n-1} × 2^{n-1}) + ∑_{i=0}^{n-2} (b_i × 2^i). Pour une valeur binaire signée sur 8 bits 11111000_2, la valeur décimale est (-1 × 2^7) + (1 × 2^6) + (1 × 2^5) + (1 × 2^4) + (1 × 2^3) + 0 + 0 + 0 = -128 + 64 + 32 + 16 + 8 = -8. Pour reconvertir un nombre décimal négatif en complément à deux, inversez tous les bits de sa valeur absolue positive (complément à un) et ajoutez 1.

Quelle est la différence entre les nombres binaires signés et non signés ?▼

La distinction essentielle entre les nombres binaires signés et non signés réside dans la façon dont le bit de poids fort (MSB) est interprété : le mode non signé assigne à l'ensemble des n bits un poids positif ou nul (plage : 0 à 2^n - 1), tandis que le mode signé utilise le MSB comme indicateur de signe selon le complément à deux (plage : -2^(n-1) à +2^(n-1) - 1). Par exemple, la séquence d'octets 11111111 correspond à 255 en représentation non signée, mais équivaut à -1 en complément à deux signé. Choisir une convention de signe inappropriée provoque des anomalies critiques de dépassement arithmétique ou de rebouclage cyclique (wrap-around).

Comment convertir un nombre binaire à virgule en décimal ?▼

Pour convertir un nombre binaire fractionnaire comportant une virgule binaire (radix point) en décimal, additionnez les puissances positives de 2 pour les bits entiers à gauche de la virgule et les puissances négatives de 2 (2^-j) pour les bits fractionnaires à droite : Décimal = ∑ (b_i × 2^i) + ∑ (b_{-j} × 2^{-j}). Par exemple, pour le binaire 1011.1101_2 : partie entière = 8 + 0 + 2 + 1 = 11 ; partie fractionnaire = (1 × 2^-1 = 0,5) + (1 × 2^-2 = 0,25) + (0 × 2^-3 = 0) + (1 × 2^-4 = 0,0625) = 0,8125. La somme donne 11,8125 en décimal.

Pourquoi les ordinateurs utilisent-ils le binaire plutôt que le décimal ?▼

Les ordinateurs recourent au binaire plutôt qu'au système décimal car les transistors physiques à semi-conducteurs fonctionnent avec une marge d'immunité au bruit maximale et une absence totale d'ambiguïté électrique entre deux états stables : passant / saturé (tension haute, représentant l'état logique 1) et bloqué (tension nulle ou masse, représentant l'état logique 0). Un ordinateur électronique décimal en base 10 devrait discriminer 10 seuils de tension très étroits (ex. 0,3 V, 0,6 V, 0,9 V), ce qui le rendrait extrêmement vulnérable aux bruits thermiques, à l'usure des composants et aux fuites capacitives, tandis que la commutation binaire s'interface nativement avec l'algèbre de Boole et les portes logiques CMOS.

Pourquoi la fonction parseInt de JavaScript donne-t-elle des résultats erronés sur 64 bits ?▼

La fonction parseInt() de JavaScript convertit les chaînes binaires en nombres flottants double précision selon la norme IEEE 754, qui ne garantit que 53 bits de précision exacte pour la mantisse entière (Number.MAX_SAFE_INTEGER = 2^53 - 1 = 9 007 199 254 740 991). Lors du parsing d'un entier binaire de 64 bits dépassant 53 bits, les 11 bits de poids faible sont arrondis au nombre flottant représentable le plus proche, générant une altération silencieuse des données. Pour des conversions complètes sur 64 ou 128 bits, aussi bien signées que non signées, vous devez utiliser le type natif en précision arbitraire BigInt('0b' + binaryString).

Outils et utilitaires connexes

Tous les outils →
Convertisseur HEX en RGBA (Opacité)converter

Convertissez instantanément des codes couleur HEX en RGBA avec opacité et transparence alpha. Prise en charge des formats hex à 3, 6 et 8 caractères, conversion par lots et code CSS prêt à l'emploi.

Ouvrir l'outil→
Calculateur de Commission Commercialefinance

Calculateur de commissions pour simuler la rémunération variable, barèmes progressifs par paliers, partage d'honoraires et frais d'agence. Projetez vos revenus OTE ou déterminez l'objectif de vente inversé pour atteindre votre quota.

Ouvrir l'outil→
Roue de Décision & Tirage au SortUtilitaire

Tirez au sort des choix, noms ou gagnants avec pondérations personnalisées, mode élimination, tirages cryptographiques CSPRNG équitables et générateur d'équipes.

Ouvrir l'outil→
Calculateur d'Intérêts Simples & Prêtfinance

Calculez les intérêts simples, le remboursement total et la valeur acquise à terme avec décompte exact des jours. Déterminez le capital, le taux ou la durée et comparez l'écart aux intérêts composés.

Ouvrir l'outil→
Simulateur Rachat Crédit Autofinance

Calculez vos économies mensuelles, la réduction du coût des intérêts et votre seuil de rentabilité lors du rachat de crédit auto. Comparez taux TAEG, durées et frais.

Ouvrir l'outil→
Calculateur FC Cible & Zones Cardiohealth

Calculez votre fréquence cardiaque cible et vos 5 zones d'entraînement aérobie (Karvonen et Tanaka). Optimisez la combustion des graisses, la VO2 max et votre endurance.

Ouvrir l'outil→