Portes logiques : AND, OR, NOT

Pourquoi apprendre ces portes ?

Vous appuyez sur « Envoyer » dans une application. Pour lancer l'envoi, il faut un message présent ET une connexion disponible. À l'échelle du programme, c'est une condition. À l'échelle d'un circuit, on peut représenter chaque réponse par un bit : 1 pour oui, 0 pour non. Une porte combine ces signaux selon une règle fixe.

Les portes ne lisent pas elles-mêmes votre message : le logiciel et d'autres circuits ont déjà traduit les états utiles en signaux. Elles servent à comprendre comment une décision simple devient un calcul matériel. Vous retrouverez aussi leurs règles dans les opérateurs sur les bits, notamment pour tester les droits d'accès d'un fichier (les rwx croisés avec ls au chapitre Terminal).

Objectifs

À la fin de cette leçon, vous saurez :

• lire une table de vérité pour AND, OR, NOT (et XOR) ;
• expliquer comment des portes combinées calculent un résultat ;
• décrire l'addition d'un bit avec retenue à l'aide de portes ;
• faire le lien avec les opérateurs & | ^ ~ que vous utiliserez pour tester et combiner des droits d'accès.

🔗 Pour vous rafraîchir la mémoire : le binaire et les bits

Une porte = une règle ultra-simple

Une porte logique prend 1 ou 2 bits en entrée et renvoie 1 bit selon une règle fixe. Pas de mémoire, pas de programme : juste une règle câblée. Pour notre bouton « Envoyer », posons M = 1 si le message est présent et C = 1 si la connexion est disponible :

Message M	Connexion C	M AND C : prêt à envoyer ?
0	0	0
0	1	0
1	0	0
1	1	1

Cette table de vérité liste tous les cas possibles. Comme deux interrupteurs en série, AND ne laisse passer le signal que si les deux entrées valent 1.

Porte	Symbole	Règle
AND (&)	A · B	1 seulement si A et B valent 1
OR (|)	A + B	1 si A ou B vaut 1
NOT (~)	¬A	inverse : ¬0 = 1, ¬1 = 0
XOR (^)	A ⊕ B	1 si exactement un vaut 1

Lisons chaque table ligne par ligne — il n'y a que quatre cas pour deux entrées :

AND : 0·0=0, 0·1=0, 1·0=0, 1·1=1   (seul le dernier cas donne 1)
OR  : 0+0=0, 0+1=1, 1+0=1, 1+1=1   (un seul 1 suffit)
XOR : 0⊕0=0, 0⊕1=1, 1⊕0=1, 1⊕1=0   (comme OR, sauf 1⊕1=0)
NOT : ¬0=1, ¬1=0                    (sur un seul bit, ex. NOT 0101 = 1010)

Moyen mnémotechnique :

• AND = robinet double en série (les deux doivent être ouverts) ;
• OR = deux robinets en parallèle (un suffit) ;
• NOT = interrupteur inverseur ;
• XOR = "l'un ou l'autre, mais pas les deux".

Autre besoin concret : envoyer par Wi-Fi ou par réseau mobile. Si les deux fonctionnent, l'envoi reste possible : il faut OR, qui accepte 1 OR 1 = 1. XOR refuserait ce cas (1 XOR 1 = 0). NOT peut représenter « hors ligne » à partir du bit « connecté ».

Vérifiez au REPL — ce sont déjà des opérateurs JavaScript bit à bit (ils comparent chaque bit). Recopiez dans node comme à la leçon précédente ; le langage sera disséqué au chapitre 4, ici seules les tables comptent :

1 & 1  // 1
1 & 0  // 0
1 | 0  // 1
1 ^ 1  // 0

⚠️ & n'est pas &&. && répond « oui/non » pour une condition (5 && 3 vaut 3, la dernière valeur « vraie »). & travaille bit par bit sur des entiers (5 & 3 vaut 1, voir exercice 3). En JS courant on utilise &&, ||, ! ; & | ^ ~ servent aux calculs sur bits comme les droits d'accès.

🔎 Pour plus tard : ~0 === -1. JavaScript inverse en réalité 32 bits signés, donc ~0 donne -1. Retenez juste que NOT inverse chaque bit ; le détail du signe viendra avec les entiers signés.

Combiner des portes pour répondre à une vraie question

Notre bouton « Envoyer » doit vérifier que le message est présent et qu'au moins une connexion fonctionne. On combine OR et AND :

Wi-Fi ───┐
         OR ───┐
Mobile ──┘      AND ───→ prêt à envoyer
Message ───────┘

Si le message vaut 1, le Wi-Fi 0 et le mobile 1, OR produit 1 puis AND produit 1 : l'envoi est possible. Si le message vaut 0, même avec deux connexions actives, AND produit 0. Chaque sortie devient l'entrée d'une autre porte. C'est ainsi que des règles très courtes produisent une décision plus utile.

Suivons les signaux étape par étape :

Message	Wi-Fi	Mobile	Wi-Fi OR Mobile	→ AND avec Message	Envoi ?
1	0	1	1	1	oui
0	1	1	1	0	non (pas de message)
1	0	0	0	0	non (pas de connexion)

Additionner 1 bit : le demi-additionneur

Addition binaire, comme à l'école :

0+0 = 0
0+1 = 1
1+0 = 1
1+1 = 0 retenue 1  (on écrit 0, on retient 1)

Deux résultats : somme et retenue. Comparons l'addition avec les portes :

A	B	A + B	A XOR B (somme ?)	A AND B (retenue ?)
0	0	0, retenue 0	0	0
0	1	1, retenue 0	1	0
1	0	1, retenue 0	1	0
1	1	0, retenue 1	0	1

Les deux dernières colonnes correspondent exactement : somme = A XOR B, retenue = A AND B.

Schéma :

A ──┬──→ XOR ──→ somme
    │
B ──┼──→ AND ──→ retenue

Pour additionner plusieurs colonnes, il faut aussi traiter la retenue venue de la colonne précédente : c'est un additionneur complet, construit avec plusieurs portes. Enchaînez ces blocs et vous pouvez additionner deux nombres sur plusieurs bits. Vous verrez leur place dans le CPU à la leçon suivante.

Essayez (guide de lecture : demiAdd prend deux bits a et b, et renvoie un paquet { somme, retenue } — la somme calculée avec ^, la retenue avec & ; accolades et return seront disséqués au chapitre JavaScript) :

// demi-additionneur en JS
function demiAdd(a, b) {
  return { somme: a ^ b, retenue: a & b };
}
demiAdd(1, 1) // { somme: 0, retenue: 1 }
demiAdd(0, 1) // { somme: 1, retenue: 0 }

Pourquoi c'est déjà des droits d'accès

Au chapitre Terminal, ls -la affichait des lignes comme -rwxr-xr-x sans les expliquer. Bonne nouvelle : vous savez désormais les lire. Chaque lettre est un bit : présente = 1, - = 0. rwx signifie lecture, écriture, exécution :

rwx  →  1 1 1  (tout permis)
rw-  →  1 1 0  (lecture + écriture, pas d'exécution)
r--  →  1 0 0  (lecture seule)

Le système teste un droit avec AND : il garde le bit demandé et efface le reste. Vos droits sont rw- (110), le système teste l'exécution (001) :

110 AND 001 = 000  →  résultat nul : pas d'exécution

Avec rwx (111), le même test donne 001 (non nul) : exécution autorisée. Pour ajouter un droit, on combine avec OR : 110 OR 001 = 111. Pour retirer l'écriture, on combine avec le NOT du droit : 110 AND (NOT 010) = 110 AND 101 = 100 (r--). Tester, ajouter, retirer : trois usages directs de AND, OR et NOT, sans aucun circuit à souder.

Au chapitre Administration, vous verrez que ces triplets s'écrivent aussi en chiffres (chmod 750) : c'est la même information, dans une autre écriture — comme le binaire et l'hexadécimal.

Dans une condition JavaScript, on emploie généralement &&, || et !. Les opérateurs &, |, ^ et ~ montrés ici travaillent bit par bit sur des entiers. 5 && 3 vaut 3 (logique), 5 & 3 vaut 1 (voir exercice 3) : & et && n'ont donc pas le même usage.

Exercice

1. Le message est présent (1) mais la connexion absente (0) : que répond la porte AND du bouton « Envoyer » ? Calculez aussi 1 OR 1 et 1 XOR 1 pour les deux connexions disponibles.
2. Avec un demi-additionneur, calculez 1+1 : somme ? retenue ? Et 0+1 ?
3. Vos droits sur un fichier sont r-x (soit 101 = 5). Testez le droit d'exécution avec 5 & 1. Puis détaillez 5 & 3 en binaire 8 bits (0101 & 0011) et lisez le résultat comme des droits.
4. Quelle porte donne 1 quand les deux entrées sont différentes ? Et quand au moins une vaut 1 ?
5. Avec message = 1, Wi-Fi = 0 et mobile = 0, calculez la sortie du circuit « prêt à envoyer ». Recommencez avec mobile = 1.

Résumé

• AND = les deux à 1, OR = au moins un à 1, NOT = inverse, XOR = exactement un à 1.
• Des portes combinées calculent : demi-additionneur = XOR (somme) + AND (retenue).
• Le CPU n'est qu'un assemblage massif de ces briques, répétées et cadencées.
• Les opérateurs JS & | ^ ~ sont les mêmes portes, bit par bit — directement utiles pour tester et combiner des droits (rwx).