🧮 Opérations Bitwise en JavaScript : Bases, Exemples et Astuces Amusantes

Bonjour chers héros du code ! 👋
Aujourd’hui, nous allons découvrir l’arme un peu mystérieuse mais super puissante de JavaScript : les opérateurs bitwise.
Préparez-vous : nous allons apprendre, un peu mélanger nos cerveaux et rencontrer des moments drôles 😏

Apprendre les opérateurs bitwise, c’est comme jeter un coup d’œil dans le cerveau d’un ordinateur. Nous plongeons dans le monde des 0 et des 1 ! 🌐

🔹 1️⃣ Qu’est-ce que les opérateurs bitwise et pourquoi les utiliser ?

Les opérateurs bitwise permettent de manipuler les nombres au niveau binaire.
Comme les ordinateurs voient les nombres en 0 et 1, ces opérateurs sont parfaits pour les tâches sensibles à la performance et pour les flags/masks.

Principaux opérateurs bitwise et leur signification :

💡 Astuce : Les opérateurs bitwise sont principalement utilisés pour les permissions, les paramètres, les masks et les opérations sensibles à la performance.

🔹 2️⃣ Bitwise AND (&) : 1 seulement si les deux sont 1

AND bitwise donne 1 seulement si les deux bits sont 1, sinon 0.
Logique : « Si nous deux disons oui → oui » 😏

Exemple 1 :

let a = 5; // 0101
let b = 3; // 0011
console.log(a & b); // 0101 & 0011 = 0001 → 1

Explication :

• Comparer chaque bit de 0101 et 0011
• Seul le bit le plus à droite est 1 dans les deux → résultat 1
• Les autres sont 0

💡 Astuce pratique : AND est parfait pour le masquage. Si vous voulez vérifier des bits spécifiques d’un nombre, utilisez AND.

Exemple 2 : Vérification de permissions

const READ = 1 << 0; // 0001
const WRITE = 1 << 1; // 0010
let permissions = READ | WRITE; // 0011

console.log((permissions & WRITE) !== 0); // true

Façon simple de stocker et vérifier les permissions de lecture/écriture dans un seul nombre 😎

🔹 3️⃣ Bitwise OR (|) : Un seul 1 suffit

OR donne 1 si au moins un bit est 1.
Logique : « Si je dis oui ou toi tu dis oui → oui » 😏

Exemple :

let a = 5;  // 0101
let b = 3;  // 0011
console.log(a | b); // 0101 | 0011 = 0111 → 7

Explication :

• Comparer chaque bit, écrire 1 si au moins un bit est 1
• Résultat : 0111 → 7

💡 Astuce : OR est idéal pour activer des bits / flags.

🔹 4️⃣ Bitwise XOR (^) : 1 si différent

XOR donne 1 si les bits sont différents, 0 si identiques.
Parfait pour basculer un état. 🎛️

Exemple :

let a = 5;  // 0101
let b = 3;  // 0011
console.log(a ^ b); // 0101 ^ 0011 = 0110 → 6

Explication :

• Comparer 0101 et 0011
• Bits différents → 1, bits identiques → 0 → 0110 → 6

💡 Astuce : XOR est pratique pour bascule de bits ou simple cryptage, comme allumer/éteindre un interrupteur 💡💡

🔹 5️⃣ Bitwise NOT (~) : Inverser

NOT inverse tous les bits : 0 → 1, 1 → 0.
Attention : en JavaScript, cela produit des nombres négatifs 😅

Exemple :

let a = 5; // 0101
console.log(~a); // 1010 → -6 (complément à deux)

Explication :

• 5 en binaire : 0101
• Inverser → 1010
• Complément à deux → -6

💡 Astuce : Faites attention avec NOT, les nombres négatifs peuvent être déroutants !

🔹 6️⃣ Opérateurs de décalage : Décaler et multiplier/diviser

Les opérateurs de décalage déplacent les bits à gauche ou à droite :

• Décalage à gauche (<<) : décale à gauche, nouveaux bits 0 → comme une multiplication rapide
• Décalage à droite (>>) : décale à droite, conserve le bit de signe → comme une division rapide
• Décalage à droite sans signe (>>>) : décale à droite, remplissage 0 → garantit un résultat positif

Exemple Left Shift :

console.log(5 << 1); // 0101 → 1010 → 10

Exemple Right Shift :

console.log(-10 >> 1); // -5

Exemple Zero-fill Right Shift :

console.log(-10 >>> 1); // 2147483643

💡 Astuce : Les décalages sont parfaits pour la performance et la manipulation de bits.

🔹 7️⃣ Exemple pratique : Permissions et flags

Supposons que vous ayez 3 permissions différentes :

const READ  = 1 << 0; // 0001
const WRITE = 1 << 1; // 0010
const EXEC  = 1 << 2; // 0100

let permissions = READ | EXEC; // 0101

console.log((permissions & WRITE) !== 0); // false
console.log((permissions & READ) !== 0);  // true

💡 Astuce : Les opérateurs bitwise sont super utiles pour les permissions et les réglages.

🔹 8️⃣ Erreurs drôles et moments amusants

• Toggle avec XOR et un bit est incorrect → “Hmm, pourquoi ça n’a pas changé ?” 😂
• NOT donne des nombres négatifs → “Négatif ou positif ?” 😅
• Décalage de grands nombres → “Wow, le nombre est passé à 2 milliards !” 😲

🔹 9️⃣ Résumé et astuces

1. Les opérateurs bitwise manipulent les nombres au niveau binaire.
2. Principaux opérateurs : &, |, ^, ~, <<, >>, >>>.
3. Utilisations pratiques : masks, flags, permissions, opérations performantes.
4. Les décalages permettent des opérations rapides similaires à la multiplication/division.
5. Les erreurs drôles et la confusion sont normales 😎

💡 Mini Astuce : Testez-les avec de petits exemples, voyez les bits en action et votre cerveau va “cliquer” !