JavaScript - Opérateurs Logiques

Salut à toi, futurs magiciens JavaScript ! Aujourd'hui, nous allons entreprendre un voyage passionnant à la découverte du monde des opérateurs logiques. Ne t'inquiète pas si tu es nouveau dans le monde de la programmation – je serai ton guide amical, et nous explorerons ce sujet pas à pas. À la fin de cette leçon, tu manipuleras les opérateurs logiques comme un pro !

Opérateurs Logiques JavaScript

Les opérateurs logiques sont les décideurs du monde de la programmation. Ils nous aident à faire des choix et à contrôler le déroulement de notre code. En JavaScript, nous avons trois principaux opérateurs logiques :

Opérateur	Nom	Description
&&	ET	Retourne true si les deux opérandes sont true
||	OU	Retourne true si au moins une des opérandes est true
!	NON	Inverse la valeur booléenne de son opérande

Plongons dans chacun de ces opérateurs et voyons comment ils font leurs merveilles !

Opérateur Logique ET (&&)

L'opérateur ET (&&) est comme un parent strict – il ne retourne true que si les deux opérandes sont true. Si l'un des opérandes est false, le résultat est false.

Voici quelques exemples :

let isAdult = true;
let hasID = true;

console.log(isAdult && hasID); // Output: true

let isTired = true;
let hasCoffee = false;

console.log(isTired && hasCoffee); // Output: false

Dans le premier exemple, isAdult et hasID sont tous deux true, donc le résultat est true. C'est comme dire : "Tu peux entrer dans le club si tu es adulte ET que tu as une carte d'identité." Les deux conditions doivent être remplies.

Dans le second exemple, bien que isTired soit true, hasCoffee est false, donc le résultat est false. C'est comme dire : "Je serai productif si je suis fatigué ET que j'ai du café." Comme il n'y a pas de café, la productivité n'arrive pas !

Opérateur Logique OU (||)

L'opérateur OU (||) est plus tolérant – il retourne true si au moins l'un des opérandes est true. Il ne retourne false que si les deux opérandes sont false.

Voici quelques exemples :

let hasCash = true;
let hasCard = false;

console.log(hasCash || hasCard); // Output: true

let isRaining = false;
let isSnowing = false;

console.log(isRaining || isSnowing); // Output: false

Dans le premier exemple, hasCash est true, donc même si hasCard est false, le résultat est true. C'est comme dire : "Tu peux acheter l'article si tu as de l'argent OU une carte." Avoir l'un ou l'autre suffit.

Dans le second exemple, isRaining et isSnowing sont tous deux false, donc le résultat est false. C'est comme dire : "Je vais rester à l'intérieur si il pleut OU qu'il neige." Puisque ni l'un ni l'autre ne se produit, tu peux sortir !

Opérateur Logique NON (!)

L'opérateur NON (!) est le rebelle du groupe – il inverse la valeur booléenne de son opérande. Si quelque chose est true, il le rend false, et vice versa.

Voyons comment il fonctionne :

let isSunny = true;

console.log(!isSunny); // Output: false

let isMonday = false;

console.log(!isMonday); // Output: true

Dans le premier exemple, isSunny est true, mais !isSunny est false. C'est comme dire : "Ce n'est pas ensoleillé," alors qu'il l'est réellement.

Dans le second exemple, isMonday est false, mais !isMonday est true. C'est comme célébrer que ce n'est pas lundi !

Précedence des Opérateurs Logiques

Comme dans les mathématiques, les opérateurs logiques ont une ordre de précedence. Voici comment ils se classent :

1. NON (!)
2. ET (&&)
3. OU (||)

Cela signifie que NON est évalué en premier, puis ET, et enfin OU. Voici un exemple :

let a = true;
let b = false;
let c = true;

console.log(a || b && !c); // Output: true

Voici comment c'est évalué :

1. D'abord, !c est évalué : !true devient false
2. Ensuite, b && false est évalué : false && false est false
3. Enfin, a || false est évalué : true || false est true

Donc, le résultat final est true.

Évaluation Court-Circuit

L'évaluation court-circuit est un truc ingénieux que JavaScript utilise pour optimiser les opérations logiques. Cela signifie que dans certains cas, JavaScript n'a pas besoin d'évaluer toutes les parties d'une expression logique pour déterminer le résultat.

Pour l'opérateur ET :

console.log(false && anything); // Output: false

Dans ce cas, JavaScript sait que si le premier opérande est false, l'expression entière sera false, donc il ne se gave même pas de evaluated anything.

Pour l'opérateur OU :

console.log(true || anything); // Output: true

Ici, JavaScript voit que le premier opérande est true, donc il sait que l'expression entière sera true, indépendamment de ce que anything est.

Cela peut être vraiment utile pour éviter des erreurs. Par exemple :

let user = null;

console.log(user && user.name); // Output: null

Si user est null, JavaScript fait court-circuit et retourne null sans essayer d'accéder à user.name, ce qui causerait une erreur.

Et voilà, les amis ! Vous avez vient de terminer votre cours intensif sur les opérateurs logiques JavaScript. Souvenez-vous, ces petits symboles sont des outils puissants dans votre boîte à outils de programmation. Ils vous aident à prendre des décisions, à contrôler le flux de votre code, et même à prévenir des erreurs.

While vous continuez votre voyage JavaScript, vous trouverez que vous utilisez ces opérateurs de plus en plus. N'ayez pas peur de les expérimenter – c'est ainsi que vous les maîtriserez vraiment. Bon codage, et que vos opérations logiques vous apportent toujours les résultats que vous attendez !

Credits: Image by storyset