Les opérations binaires sont des opérations effectuées sur les nombres au niveau des bits. JavaScript fournit un ensemble d’opérateurs pour effectuer des opérations binaires. Ces opérateurs sont très utiles dans les situations où une programmation de bas niveau ou une optimisation des performances est nécessaire. Dans cet article, nous allons explorer les opérations binaires en JavaScript et comment les utiliser à l’aide d’exemples de code.
Opérateurs binaires
En JavaScript, les opérateurs binaires traitent les nombres comme des entiers sur 32 bits et effectuent des opérations au niveau des bits. Voici les opérateurs binaires de base :
- ET (&)
- OU (|)
- OU exclusif (^)
- NON (~)
- Décalage à gauche (<<)
- Décalage à droite avec propagation du signe (>>)
- Décalage à droite sans propagation du signe (>>>)
ET (&)
L’opérateur ET compare chaque bit des deux opérandes et renvoie 1 si les deux bits sont égaux à 1, sinon il renvoie 0.
let a = 5; // 0101
let b = 3; // 0011
let result = a & b; // 0001 (1)
console.log(result); // Sortie : 1
OU (|)
L’opérateur OU compare chaque bit des deux opérandes et renvoie 1 si au moins un des bits est égal à 1.
let a = 5; // 0101
let b = 3; // 0011
let result = a | b; // 0111 (7)
console.log(result); // Sortie : 7
OU exclusif (^)
L’opérateur OU exclusif compare chaque bit des deux opérandes et renvoie 1 si un seul des bits est égal à 1, sinon il renvoie 0.
let a = 5; // 0101
let b = 3; // 0011
let result = a ^ b; // 0110 (6)
console.log(result); // Sortie : 6
NON (~)
L’opérateur NON inverse tous les bits d’un seul opérande.
let a = 5; // 0101
let result = ~a; // 1010 (en JavaScript, -6)
console.log(result); // Sortie : -6
Décalage à gauche (<<)
L’opérateur de décalage à gauche déplace les bits d’un nombre vers la gauche d’un certain nombre de positions. Les bits vides à droite sont remplis avec des zéros.
let a = 5; // 0101
let result = a << 1; // 1010 (10)
console.log(result); // Sortie : 10
Décalage à droite avec propagation du signe (>>)
L’opérateur de décalage à droite avec propagation du signe déplace les bits d’un nombre vers la droite d’un certain nombre de positions. Les bits vides à gauche sont remplis en fonction du bit de signe du nombre d’origine.
let a = -10; // 11110110 (en représentation 8 bits)
let result = a >> 1; // 11111011 (-5)
console.log(result); // Sortie : -5
Décalage à droite sans propagation du signe (>>>)
L’opérateur de décalage à droite sans propagation du signe déplace les bits d’un nombre vers la droite d’un certain nombre de positions. Les bits vides à gauche sont toujours remplis avec des zéros.
let a = -10; // 11110110 (en représentation 8 bits)
let result = a >>> 1; // 01111101 (en représentation 32 bits, 2147483643)
console.log(result); // Sortie : 2147483643
Domaines d’application des opérateurs binaires
Les opérateurs binaires sont utilisés dans divers domaines :
- Masquage Les opérateurs binaires sont utilisés pour vérifier ou modifier certains bits d’un nombre.
let value = 0b1010; // 10 en décimal
let mask = 0b0100; // 4 en décimal
let masked = value & mask; // 0000 (0)
console.log(masked); // Sortie : 0
- Manipulation des bits L’utilisation des indicateurs (flags) sert à définir ou à effacer certains bits.
let flags = 0b1010; // 10 en décimal
// Définir le 1er bit
flags = flags | 0b0001; // 1011 (11)
console.log(flags); // Sortie : 11
// Effacer le 3e bit
flags = flags & ~0b1000; // 0011 (3)
console.log(flags); // Sortie : 3
- Optimisation des performances Certaines opérations mathématiques peuvent être effectuées plus rapidement avec des opérateurs binaires.
// Multiplier par 2
let value = 5;
let result = value << 1; // 10
console.log(result); // Sortie : 10
// Diviser par 2
result = value >> 1; // 2
console.log(result); // Sortie : 2
Conclusion
Les opérateurs binaires offrent un ensemble d’outils puissant et flexible en JavaScript. Ces opérateurs permettent d’effectuer des opérations binaires sur les nombres et peuvent être utilisés dans des domaines tels que l’optimisation des performances, la manipulation des bits et l’utilisation des indicateurs. Comprendre et utiliser correctement les opérateurs binaires vous aidera à écrire un code JavaScript plus efficace et performant.