Comment utiliser les opérateurs logiques en JavaScript

Les opérateurs logiques permettent d’effectuer des opérations logiques sur des valeurs booléennes. Ils vous permettent de combiner, d’annuler ou de comparer des valeurs booléennes et de prendre des décisions logiques dans votre code en fonction du résultat.

Explorez les différents opérateurs logiques pris en charge par JavaScript, y compris l’opérateur de coalescence ES6 Nullish.

L’opérateur logique AND (&&amp 😉

L’opérateur ET (&&amp 😉 est un opérateur logique qui renvoie les données suivantes vrai si les deux opérandes sont évalués à vrai et faux autrement.

Voici la syntaxe de l’opérateur AND :

 a && b
 

Voici un exemple d’utilisation de l’opérateur ET :

 const a = 5;
const b = 10;
const c = 15;

const result_1 = (a < b) && (b < c);
console.log(result_1); // true

const result_2 = (a > b) && (b < c);
console.log(result_2); // false
 

Dans cet exemple, résultat_1 s’évalue à vrai car les deux opérandes de l’expression valent vrai. Cependant, résultat_2 évalue à faux car le premier opérande (a &gt ; b) renvoie faux.

Si les deux opérandes ne sont pas des booléens, JavaScript tentera de les convertir en valeurs booléennes avant d’évaluer l’expression. Pour les convertir en booléens, JavaScript évalue d’abord si les valeurs sont vraies ou fausses.

JavaScript considère toute valeur qui n’est pas explicitement fausse comme une valeur vraie. Une fois converties, elles sont évaluées comme des booléens vrai.

Cependant, certaines valeurs et certains types de données en JavaScript ne sont pas fiables, de sorte que lorsque JavaScript les convertit, ils sont évalués comme des booléens. faux.

Les valeurs falsy en JavaScript sont :

• faux
• null
• non défini
• NaN (Pas un nombre)
• 0
• BigInt (0n)
• Chaîne vide («  » ou  » ou « )
• non défini

Lorsque vous utilisez l’opérateur AND pour évaluer des valeurs non booléennes, l’expression renvoie immédiatement la valeur du premier opérande si l’opérande est faux sans évaluer le second. Ce comportement est connu sous le nom de court-circuitage, et vous pouvez l’utiliser pour écrire des instructions conditionnelles en JavaScript.

Cependant, si le premier opérande est vrai, l’expression procède à l’évaluation du second opérande. Si le second opérande est vrai, elle le renvoie.

Par exemple :

 const a = 5;
const b = 'Hello';
const c = null;

const result_1 = a && b;
console.log(result_1); // "Hello"

const result_2 = c && b;
console.log(result_2); // null
 

Dans cet exemple, result_1 est évaluée à « Hello » car les deux opérandes de l’expression sont vrais. Cependant, résultat_2 courts-circuits et retours nul sans évaluer le second opérande.

Notez que s’il y a plus d’opérandes, l’opérateur ET continuera à les évaluer jusqu’à ce qu’il rencontre une valeur fausse. S’il ne rencontre pas de valeur fausse, il renvoie la dernière valeur vraie qu’il a rencontrée.

L’opérateur logique OR (||)

L’opérateur OR (||) est un opérateur logique qui retourne vrai si et seulement si un ou plusieurs de ses opérandes sont vrai. Il ne renvoie que faux lorsque les deux opérandes sont faux.

Voici la syntaxe de l’opérateur OR :

 a || b
 

Voici un exemple d’utilisation de l’opérateur OR :

 const a = 5;
const b = 10;
const c = 15;

const result_1 = (a < b) || (b < c);
console.log(result_1); // true

const result_2 = (a > b) || (b < c);
console.log(result_2); // true

const result_3 = (a > b) || (b > c);
console.log(result_3); // false
 

Dans l’exemple ci-dessus, result_1 évalue à vrai car les deux opérandes de l’expression valent vrai. résultat_2 évalue à vrai car le second opérande est évalué à vrai. result_3 évalue à faux car les deux opérandes de l’expression valent faux.

Lorsque vous utilisez l’opérateur OR dans des contextes non booléens, JavaScript tente de convertir les valeurs booléennes avant d’évaluer l’expression.

Lorsque l’expression est évaluée, si le premier opérande est vrai, l’opérateur court-circuite et le renvoie. Cependant, s’il est faux, il évalue l’opérande suivant jusqu’à ce qu’il rencontre un opérande vrai. Si l’expression ne contient aucun opérande vrai, il renvoie la dernière valeur erronée qu’il rencontre.

Par exemple :

 const a = 5;
const b = 'Hello';
const c = null;

const result_1 = a || b;
console.log(result_1); // 5

const result_2 = c || b;
console.log(result_2); // "Hello"

const result_3 = c || " ";
console.log(result_3); // " "
 

Dans l’exemple ci-dessus, result_1 courts-circuits et retours 5 car il s’agit d’une valeur vraie. résultat_2 renvoie « Hello » car c’est la première valeur vraie qu’il rencontre dans l’expression. result_3 renvoie une chaîne vide car il s’agit de la dernière valeur fictive de l’expression.

L’opérateur logique NOT ( !)

L’opérateur logique NOT ( !) est un opérateur unaire qui renvoie la valeur booléenne opposée à son opérande.

Voici la syntaxe de l’opérateur NOT :

 !x
 

Où x est un booléen ou une valeur vraie ou fausse.

Voici un exemple d’utilisation de l’opérateur NOT :

 const a = 5;
const b = '';
const c = true;

const result_1 = !a;
console.log(result_1); // false

const result_2 = !b;
console.log(result_2); // true

const result_3 = !c;
console.log(result_3); // false
 

Dans l’exemple ci-dessus, l’opérateur NOT renvoie la valeur inverse des opérandes booléens. Lorsque vous utilisez l’opérateur NOT dans des contextes non booléens (result_1 &amp ; result_2), il convertit les valeurs vraies en la valeur inverse de vrai et convertit les valeurs falsy en la valeur inverse de faux.

L’opérateur de coalescence nulle ( ??)

L’opérateur de coalescence nulle est un opérateur logique qui évalue deux opérandes et renvoie le premier opérande s’il n’est pas nul ou non défini. Sinon, il renvoie le deuxième opérande.

À première vue, l’opérateur de fusion nul peut sembler identique à l’opérateur logique OR (||), mais ce n’est pas le cas. La principale différence est que l’opérateur OR renvoie l’opérande de droite si l’opérande de gauche est « n’importe quelle » valeur fausse, et pas seulement null ou non défini.

Il fournit un moyen concis de choisir une valeur par défaut lorsque l’on rencontre un problème de null ou non défini valeurs.

Voici la syntaxe de l’opérateur de coalescence nul :

 x ?? y
 

Voici un exemple d’utilisation de l’opérateur de coalescence nulle :

 const name = null;
const defaultName = "John Doe";

const result_1 = name ?? defaultName;
console.log(result_1); // "John Doe"

const age = 0;
const defaultAge = 25;

const result_2 = age ?? defaultAge;
console.log(result_2); // 0
 

Dans l’exemple ci-dessus, résultat_1 renvoie « John Doe » car le premier opérande a une valeur de null. résultat_2 retours 0 parce que, bien qu’il s’agisse d’une valeur fictive, elle n’est ni nulle ni non défini.

Utiliser les opérateurs logiques dans votre code

Les opérateurs logiques sont couramment utilisés pour écrire des instructions conditionnelles, attribuer des valeurs par défaut ou faire basculer des valeurs booléennes en fonction de conditions.

En utilisant ces opérateurs logiques, vous pouvez écrire un code plus concis et plus expressif qui gère différents scénarios basés sur la véracité ou la fausseté des valeurs.