Opérateurs logiques

Il y a trois opérateurs logiques en JavaScript : || (OR), && (AND), ! (NOT), ?? (Coalescence des nulles). Nous couvrons ici les trois premiers, l’opérateur ?? est dans l’article suivant.

Bien qu’ils soient appelés “logiques”, ils peuvent être appliqués à des valeurs de tout type, pas seulement booléennes. Le résultat peut également être de tout type.

Voyons les détails.

|| (OR)

L’opérateur “OR” est représenté avec deux symboles de ligne verticale :

result = a || b;

En programmation classique, le OU logique est destiné à manipuler uniquement les valeurs booléennes. Si l’un de ses arguments est true, alors il renvoie true, sinon il renvoie false.

En JavaScript, l’opérateur est un peu plus compliqué et puissant. Mais voyons d’abord ce qui se passe avec les valeurs booléennes.

Il existe quatre combinaisons logiques possibles :

alert( true  || true  ); // true
alert( false || true  ); // true
alert( true  || false ); // true
alert( false || false ); // false

Comme on peut le voir, le résultat est toujours true sauf pour le cas où les deux opérandes sont false.

Si un opérande n’est pas booléen, il est converti en booléen pour l’évaluation.

Par exemple, un nombre 1 est traité comme true, un nombre 0 – comme false :

if (1 || 0) { // fonctionne comme si ( true || false )
  alert( 'truthy!' );
}

La plupart du temps, OR || est utilisé dans une instruction if pour tester si l'une des conditions données est correcte.

Par exemple :

let hour = 9;

if (hour < 10 || hour > 18) {
  alert( 'The office is closed.' );
}

Nous pouvons passer plus de conditions :

let hour = 12;
let isWeekend = true;

if (hour < 10 || hour > 18 || isWeekend) {
  alert( 'The office is closed.' ); // c'est le weekend
}

OR "||" cherche la première valeur vraie

La logique décrite ci-dessus est quelque peu classique. Maintenant, apportons les fonctionnalités “supplémentaires” de JavaScript.

L’algorithme étendu fonctionne comme suit.

En cas de multiples valeurs liées par OR :

result = value1 || value2 || value3;

L’opérateur OR || fait ce qui suit :

• Évaluez les opérandes de gauche à droite.
• Pour chaque opérande, il le convertit en booléen. Si le résultat est true, arrêtez et retournez la valeur d’origine de cet opérande.
• Si tous les autres opérandes ont été évalués (c’est-à-dire que tous étaient false), renvoyez le dernier opérande.

Une valeur est renvoyée sous sa forme d’origine, sans conversion.

En d’autres termes, une chaîne de OR || renvoie la première valeur true ou la dernière valeur si aucune valeur true n’a été trouvée.

Par exemple :

alert( 1 || 0 ); // 1 (1 est vrai)

alert( null || 1 ); // 1 (1 est la première valeur vraie)
alert( null || 0 || 1 ); // 1 (la première valeur vraie)

alert( undefined || null || 0 ); // 0 (tous faux, renvoie la dernière valeur)

Cela conduit à des usages intéressants par rapport à un “OR pur, classique, booléen uniquement”.

1. Obtenir la première valeur vraie dans la liste des variables ou des expressions.

   Par exemple, nous avons les variables firstName, lastName et nickName, toutes optionnelles (c’est-à-dire peut être indéfini ou avoir des valeurs fausses).

   Utilisons OR || pour choisir celui qui contient les données et l’afficher (ou Anonymous si rien n’est défini) :

   let firstName = "";
   let lastName = "";
   let nickName = "SuperCoder";
   
   alert( firstName || lastName || nickName || "Anonymous"); // SuperCoder

   Si toutes les variables étaient fausses, ce serait "Anonymous" qui apparaîtrait.

2. Évaluation des courts-circuits.

   Une autre caractéristique de l’opérateur OR || est l’évaluation dite de “court-circuit”.

   Cela signifie que || traite ses arguments jusqu’à ce que la première valeur de vérité soit atteinte, puis la valeur est renvoyée immédiatement, sans même toucher l’autre argument.

   L’importance de cette fonctionnalité devient évidente si un opérande n’est pas seulement une valeur, mais une expression avec un effet secondaire, comme une affectation de variable ou un appel de fonction.

   Dans l’exemple ci-dessous, seul le deuxième message est imprimé :

   true || alert("not printed");
   false || alert("printed");

   Dans la première ligne, l’opérateur OR || arrête l’évaluation immédiatement après avoir vu true, de sorte que alert n’est pas exécuté.

   Parfois, les gens utilisent cette fonctionnalité pour exécuter des commandes uniquement si la condition sur la partie gauche est fausse.

&& (AND)

L’opérateur AND est représenté avec deux esperluettes && :

result = a && b;

En programmation classique, AND retourne true si les deux opérandes sont true et false dans les autres cas :

alert( true  && true  ); // true
alert( false && true  ); // false
alert( true  && false ); // false
alert( false && false ); // false

Un exemple avec if:

let hour = 12;
let minute = 30;

if (hour == 12 && minute == 30) {
  alert( 'Time is 12:30' );
}

Tout comme pour OR, toute valeur est autorisée en tant qu’opérande de AND :

if (1 && 0) { // évalué comme true && false
  alert( "Ne marchera pas, car le résultat est faux" );
}

AND “&&” cherche la première valeur fausse

En cas de multiples valeurs liées par AND :

result = value1 && value2 && value3;

L’opérateur AND && effectue les opérations suivantes :

• Évalue les opérandes de gauche à droite.
• Pour chaque opérande, il le convertit en booléen. Si le résultat est false, arrêtez et retournez la valeur d’origine de cet opérande.
• Si tous les autres opérandes ont été évalués (c’est-à-dire tous étaient vrais), retournez le dernier opérande.

En d’autres termes, une chaîne de AND && renvoie la première valeur false ou la dernière valeur si aucune valeur false n’a été trouvée.

Les règles ci-dessus sont similaires à OR. La différence est que AND retourne la première valeur false tandis que OR renvoie la première valeur true.

Exemples :

// si le premier opérande est vrai,
// AND retourne le second opérande :
alert( 1 && 0 ); // 0
alert( 1 && 5 ); // 5

// si le premier opérande est faux,
// AND le retourne. Le deuxième opérande est ignoré
alert( null && 5 ); // null
alert( 0 && "no matter what" ); // 0

Nous pouvons également transmettre plusieurs valeurs à la suite sur une même ligne. Voyez comment le premier faux est retourné :

alert( 1 && 2 && null && 3 ); // null

Lorsque toutes les valeurs sont vraies, la dernière valeur est renvoyée :

alert( 1 && 2 && 3 ); // 3, la dernière

let x = 1;

(x > 0) && alert( 'Greater than zero!' );

let x = 1;

if (x > 0) alert( 'Greater than zero!' );

! (NOT)

L’opérateur booléen NOT est représenté par un point d’exclamation !.

La syntaxe est assez simple :

result = !value;

L’opérateur accepte un seul argument et effectue les opérations suivantes :

1. Convertit l’opérande en type booléen : true/false.
2. Renvoie la valeur inverse.

Par exemple :

alert( !true ); // false
alert( !0 ); // true

Un double NOT !! est parfois utilisé pour convertir une valeur en type booléen :

alert( !!"non-empty string" ); // true
alert( !!null ); // false

C’est-à-dire que le premier NOT convertit la valeur en booléen et retourne l’inverse, et que le second NOT l’inverse encore. À la fin, nous avons une conversion valeur à booléen simple.

Il existe un moyen un peu plus verbeux de faire la même chose – une fonction Boolean intégrée :

alert( Boolean("non-empty string") ); // true
alert( Boolean(null) ); // false

La précédence de NOT ! est la plus élevée de tous les opérateurs binaire, il est donc toujours exécuté en premier, avant les autres.