Guide du Binaire et de la Conversion de Bases : Compréhension Visuelle des Opérations de Bits au Codage de Données

Fondements des Systèmes Numériques

Quatre Bases Courantes

Base	Radix	Chiffres	Préfixe	Exemple
Binaire	2	0,1	`0b`	`0b1010` = 10
Octal	8	0-7	`0o`	`0o12` = 10
Décimal	10	0-9	Aucun	`10`
Hexadécimal	16	0-9,A-F	`0x`	`0xA` = 10

Méthodes de Conversion

N'importe Quelle Base → Décimal

Binaire 1010 → 1×2³ + 0×2² + 1×2¹ + 0×2⁰ = 8 + 0 + 2 + 0 = 10
Hexadécimal FF → 15×16¹ + 15×16⁰ = 240 + 15 = 255

Décimal → N'importe Quelle Base

10 → Binaire :
10 ÷ 2 = 5 reste 0
5 ÷ 2 = 2 reste 1
2 ÷ 2 = 1 reste 0
1 ÷ 2 = 0 reste 1
Lire de bas en haut : 1010

255 → Hexadécimal :
255 ÷ 16 = 15 reste 15
15 ÷ 16 = 0 reste 15
Lire de bas en haut : FF

Conversion de Bases en JavaScript

// parseInt vers décimal
parseInt('1010', 2)    // 10
parseInt('FF', 16)     // 255
parseInt('12', 8)      // 10

// toString vers la base cible
(10).toString(2)       // "1010"
(255).toString(16)     // "ff"
(255).toString(8)      // "377"

// Littéraux
0b1010   // 10
0o12     // 10
0xFF     // 255

Opérations de Bits en Pratique

Six Opérations de Bits

Opération	Symbole	Exemple	Résultat
AND	`&`	`0b1100 & 0b1010`	`0b1000` (8)
OR	`	`	`0b1100
XOR	`^`	`0b1100 ^ 0b1010`	`0b0110` (6)
NOT	`~`	`~0b1100`	`-0b1101` (-13)
Décalage gauche	`<<`	`0b0011 << 2`	`0b1100` (12)
Décalage droite	`>>`	`0b1100 >> 2`	`0b0011` (3)

Application 1 : Système de Permissions

const PERMISSIONS = {
  READ:    1 << 0,  // 0b0001 = 1
  WRITE:   1 << 1,  // 0b0010 = 2
  DELETE:  1 << 2,  // 0b0100 = 4
  ADMIN:   1 << 3,  // 0b1000 = 8
};

// Combiner les permissions
const editor = PERMISSIONS.READ | PERMISSIONS.WRITE;  // 0b0011 = 3
const admin = PERMISSIONS.READ | PERMISSIONS.WRITE | PERMISSIONS.DELETE | PERMISSIONS.ADMIN;  // 0b1111 = 15

// Vérifier les permissions
function hasPermission(userPermissions: number, permission: number): boolean {
  return (userPermissions & permission) === permission;
}

hasPermission(editor, PERMISSIONS.READ);    // true
hasPermission(editor, PERMISSIONS.DELETE);  // false
hasPermission(admin, PERMISSIONS.ADMIN);    // true

// Ajouter une permission
function addPermission(userPermissions: number, permission: number): number {
  return userPermissions | permission;
}

// Retirer une permission
function removePermission(userPermissions: number, permission: number): number {
  return userPermissions & ~permission;
}

Application 2 : Indicateurs (Flags)

const FLAGS = {
  BOLD:      1 << 0,  // 1
  ITALIC:    1 << 1,  // 2
  UNDERLINE: 1 << 2,  // 4
  STRIKETHROUGH: 1 << 3, // 8
};

// Définir : gras + italique
let style = FLAGS.BOLD | FLAGS.ITALIC;  // 3

// Basculer le soulignement
style ^= FLAGS.UNDERLINE;  // 7 (ajouter le soulignement)
style ^= FLAGS.UNDERLINE;  // 3 (retirer le soulignement)

Application 3 : Couleur RGB

// RGB → nombre
function rgbToNumber(r: number, g: number, b: number): number {
  return (r << 16) | (g << 8) | b;
}

// Nombre → RGB
function numberToRgb(n: number): { r: number; g: number; b: number } {
  return {
    r: (n >> 16) & 0xFF,
    g: (n >> 8) & 0xFF,
    b: n & 0xFF,
  };
}

rgbToNumber(255, 128, 0);     // 0xFF8000 = 16744448
numberToRgb(0xFF8000);        // { r: 255, g: 128, b: 0 }

Application 4 : Calcul Rapide

// Multiplier par des puissances de 2
n * 2     === n << 1
n * 4     === n << 2
n * 8     === n << 3

// Diviser par des puissances de 2 (troncature)
n / 2     === n >> 1  // nombres positifs
Math.floor(n / 2) === n >> 1

// Vérifier pair/impair
n & 1     // 0 = pair, 1 = impair

// Modulo puissances de 2
n % 4     === n & 3
n % 8     === n & 7
n % 16    === n & 15

// Échanger deux valeurs (sans variable temporaire)
a ^= b; b ^= a; a ^= b;

Nombres à Virgule Flottante IEEE 754

Structure Double Précision (64 bits)

Bit de signe(1)  Bits d'exposant(11)    Bits de mantisse(52)
S                EEEEEEEEEEE            MMMMMMMMMMMM...MMMM

Exemple : -12,375
Signe : 1 (négatif)
Exposant : 10000000010 (1026, avec décalage 3)
Mantisse : 1001001100000000...0

Problèmes de Précision

// Problème classique
0.1 + 0.2 === 0.3   // faux !
0.1 + 0.2            // 0.30000000000000004

// Raison : 0,1 et 0,2 en binaire sont des décimales périodiques infinies
// 0,1 = 0.0001100110011... (périodique)
// 0,2 = 0.0011001100110... (périodique)

// Solutions
// 1. Utiliser l'arithmétique entière
(0.1 * 10 + 0.2 * 10) / 10  // 0.3

// 2. Utiliser toFixed
(0.1 + 0.2).toFixed(1)       // "0.3"

// 3. Utiliser la comparaison avec EPSILON
Math.abs(0.1 + 0.2 - 0.3) < Number.EPSILON  // true

Valeurs Spéciales

Number.MAX_SAFE_INTEGER    // 9007199254740991 (2^53 - 1)
Number.MIN_SAFE_INTEGER    // -9007199254740991
Number.MAX_VALUE           // 1.7976931348623157e+308
Number.EPSILON             // 2.220446049250313e-16
Infinity                   // Infini positif
-Infinity                  // Infini négatif
NaN                        // Pas un nombre

Codage Base64 et Binaire

Principe de Codage

3 octets (24 bits) → 4 caractères Base64 (6 bits chacun)

Exemple : "Man"
M = 77  = 01001101
a = 97  = 01100001
n = 110 = 01101110

Combiné : 010011010110000101101110
Groupé : 010011 010110 000101 101110
Indices :  19      22      5      46
Caractères : T       W       F       u

Résultat : "TWFu"

Utiliser l'Outil pour Coder/Décoder

Ouvrez l'outil de codage/décodage Base64
Entrez du texte ou une chaîne Base64
Cliquez sur « Coder » ou « Décoder »
Prend en charge la conversion Base64 de fichiers et d'images

Codage Hex

Table de Correspondance Binaire → Hex

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

Usages Courants

Usage	Exemple
Valeurs de couleur	`#FF8000`
Adresse MAC	`00:1A:2B:3C:4D:5E`
Valeurs de hachage	`a1b2c3d4e5f6...`
Adresses mémoire	`0x7fff5fbff8c0`
Affichage binaire	`xxd file.bin`

Utiliser ToolsKu pour la Conversion de Bases

Ouvrez l'outil de conversion de bases
Entrez une valeur
Sélectionnez la base d'entrée
Consultez les résultats de conversion dans toutes les bases

FAQ

Pourquoi les opérations de bits en JavaScript ne supportent-elles que 32 bits ?

Les opérations de bits en JavaScript convertissent les nombres en entiers signés sur 32 bits, les bits au-delà de 32 bits sont tronqués :

0xFFFFFFFF          // 4294967295 (nombre normal)
0xFFFFFFFF | 0      // -1 (dépassement lors de la conversion en int32)

// Les opérations de bits avec de grands nombres nécessitent BigInt
(0xFFFFFFFFFn & 0xFFn).toString(16)  // "ff"

Comment voir le contenu binaire d'un fichier ?

# hex dump
xxd file.bin

# Ou utilisez la visionneuse Hex de ToolsKu
# Téléchargez un fichier → voyez le contenu hexadécimal/binaire

Résumé

Le binaire est le fondement de l'informatique — les systèmes de permissions, le codage des couleurs, la précision des nombres à virgule flottante et le codage Base64 en dépendent. Maîtriser la conversion de bases et les opérations de bits permet d'écrire du code plus efficace et de bas niveau. ToolsKu offre des outils comme la Conversion de bases, le Codage/Décodage Base64 et d'autres, pour vous aider à traiter rapidement les problèmes de bases et de codage.