La logique est la base de tout programme, vous voudrez donc maîtriser les opérateurs logiques pour structurer votre code efficacement.

Les opérateurs logiques vous 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 Nullish ES6.

L'opérateur logique AND (&&)

L'opérateur AND (&&) est un opérateur logique qui renvoie vrai si les deux opérandes évaluent à vrai et FAUX sinon.

Voici la syntaxe de l'opérateur AND :

un B

Voici un exemple d'utilisation de l'opérateur AND :

constante un = 5;
constante b = 10;
constante c = 15;
constante result_1 = (a < b) && (b < c);
console.log (résultat_1); // vrai
constante result_2 = (a > b) && (b < c);
console.log (result_2); // FAUX

Dans cet exemple, result_1 évalue à vrai car les deux opérandes de l'expression sont évalués à

instagram viewer
vrai. Cependant, result_2 évalue à FAUX car le premier opérande (un > b) Retour FAUX.

Si les deux opérandes ne sont pas 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 véridique. Une fois convertis, ils s'évaluent en un booléen vrai.

Cependant, certaines valeurs et types de données en JavaScript sont faux, donc quand JavaScript les convertit, ils sont évalués à un booléen FAUX.

Les fausses valeurs en JavaScript sont :

  • FAUX
  • nul
  • indéfini
  • NaN (Pas un numéro)
  • 0
  • BigInt (0n)
  • Chaîne vide ("" ou '' ou ``)
  • indé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-circuit et vous pouvez l'utiliser pour écrire instructions conditionnelles en JavaScript.

Cependant, si le premier opérande est véridique, l'expression procède à l'évaluation du deuxième opérande. Si le deuxième opérande est véridique, il le renvoie.

Par exemple:

constante un = 5;
constante b = 'Bonjour';
constante c = nul;
constante result_1 = un && b;
console.log (résultat_1); // "Bonjour"
constante result_2 = c && b;
console.log (result_2); // nul

Dans cet exemple, result_1 est évalué à "Bonjour" car les deux opérandes de l'expression sont véridiques. Cependant, result_2 courts-circuits et retours nul sans évaluer le deuxième opérande.

Notez que s'il y a plus d'opérandes, l'opérateur AND 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 véridique rencontrée.

L'opérateur logique OR (||)

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

Voici la syntaxe de l'opérateur OR :

un || b

Voici un exemple de l'opérateur OR utilisé :

constante un = 5;
constante b = 10;
constante c = 15;
constante résultat_1 = (a < b) || (b < c);
console.log (résultat_1); // vrai


constante résultat_2 = (a > b) || (b < c);
console.log (result_2); // vrai
constante résultat_3 = (a > b) || (b > c);
console.log (résultat_3); // FAUX

Dans l'exemple ci-dessus, result_1 évalue à vrai car les deux opérandes de l'expression sont évalués à vrai. result_2 évalue à vrai parce que le deuxième opérande est évalué à vrai. result_3 évalue à FAUX car les deux opérandes de l'expression sont évalués à FAUX.

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

Lorsque l'expression est évaluée, si le premier opérande est véridique, l'opérateur court-circuite et le renvoie. Cependant, s'il est faux, il procède à l'évaluation de l'opérande suivant jusqu'à ce qu'il rencontre un opérande véridique. S'il n'y a pas d'opérandes véridiques dans l'expression, elle renvoie la dernière valeur fausse rencontrée.

Par exemple:

constante un = 5;
constante b = 'Bonjour';
constante c = nul;
constante résultat_1 = un || b;
console.log (résultat_1); // 5


constante résultat_2 = c || b;
console.log (result_2); // "Bonjour"
constante résultat_3 = c || " ";
console.log (résultat_3); // " "

Dans l'exemple ci-dessus, result_1 courts-circuits et retours 5 parce que c'est une valeur de vérité. result_2 renvoie "Bonjour" car il s'agit de la première valeur de vérité qu'il rencontre dans l'expression. result_3 renvoie une chaîne vide car il s'agit de la dernière valeur fausse de l'expression.

L'opérateur logique NON (!)

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 vrai ou faux.

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

constante un = 5;
constante b = '';
constante c = vrai;
constante result_1 = !a;
console.log (résultat_1); // FAUX


constante result_2 = !b;
console.log (result_2); // vrai
constante result_3 = !c;
console.log (résultat_3); // FAUX

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 & result_2), il convertit les valeurs de vérité en la valeur inverse de vrai et convertit les valeurs fausses en 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 indéfini. Sinon, il renvoie le deuxième opérande.

En un coup d'œil, l'opérateur de coalescence 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, pas seulement nul ou indéfini.

Il fournit un moyen concis de choisir une valeur par défaut lors de la rencontre nul ou indéfini valeurs.

Voici la syntaxe de l'opérateur de coalescence nulle :

X?? y

Voici un exemple de l'opérateur de coalescence nulle utilisé :

constante nom = nul;
constante nom_défaut = "John Doe";
constante result_1 = nom?? defaultName ;
console.log (résultat_1); // "John Doe"


constante âge = 0;
constante defaultAge = 25;
constante result_2 = âge? ? defaultAge ;
console.log (result_2); // 0

Dans l'exemple ci-dessus, result_1 renvoie "John Doe" car le premier opérande avait une valeur de nul. result_2 Retour 0 parce que, bien que ce soit une fausse valeur, ce n'est ni nul ni indéfini.

Utiliser des 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 basculer des valeurs booléennes en fonction de conditions.

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