JavaScript - Opérateurs

Salut à toi, futurs magiciens JavaScript ! Je suis ravi de devenir ton guide sur ce voyage passionnant dans le monde des opérateurs JavaScript. En tant que quelqu'un qui enseigne la programmation depuis des années, je peux te dire que comprendre les opérateurs, c'est comme apprendre le secret de la poignée de main du monde de la programmation. Alors, plongeons dedans et dévoilons ces mystères ensemble !

Qu'est-ce qu'un Opérateur ?

Avant de rentrer dans les détails, intéressons-nous aux bases. En JavaScript, un opérateur est un symbole spécial utilisé pour effectuer des opérations sur des opérandes (valeurs et variables). Pense aux opérateurs comme aux verbes dans le langage de la programmation - ce sont les actions qui font que les choses se passent !

Par exemple, dans l'expression 2 + 3, le + est l'opérateur, tandis que 2 et 3 sont les opérandes. Simple, non ?

Opérateurs Arithmétiques JavaScript

Passons maintenant aux opérateurs arithmétiques. Ceux-ci sont la base des opérations mathématiques en JavaScript. Souviens-toi de ces cours de mathématiques que tu as suivis ? Eh bien, il est temps de ressortir cette connaissance !

Voici un tableau des opérateurs arithmétiques :

Opérateur	Description	Exemple
+	Addition	5 + 3 = 8
-	Soustraction	5 - 3 = 2
*	Multiplication	5 * 3 = 15
/	Division	15 / 3 = 5
%	Modulo (Reste)	5 % 2 = 1
++	Incrément	Let x = 5; x++; (Maintenant x est 6)
--	Décrément	Let x = 5; x--; (Maintenant x est 4)

Voyons-les en action :

let a = 10;
let b = 5;

console.log(a + b); // Output: 15
console.log(a - b); // Output: 5
console.log(a * b); // Output: 50
console.log(a / b); // Output: 2
console.log(a % b); // Output: 0

a++; // a est maintenant 11
console.log(a); // Output: 11

b--; // b est maintenant 4
console.log(b); // Output: 4

Chaque ligne dans cet extrait de code montre comment ces opérateurs fonctionnent. L'opérateur modulo (%) pourrait être nouveau pour certains d'entre vous - il vous donne le reste après la division. Il est incroyablement utile lorsque vous avez besoin de vérifier si un nombre est pair ou impair !

Opérateurs de Comparaison JavaScript

Passons aux opérateurs de comparaison. Ceux-ci sont comme les juges dans un concours de programmation - ils comparent des valeurs et renvoient vrai ou faux. Ils sont essentiels pour prendre des décisions dans votre code.

Voici un tableau des opérateurs de comparaison :

Opérateur	Description	Exemple
==	Égal à	5 == 5 renvoie true
===	Égal strict (valeur et type)	5 === "5" renvoie false
!=	Différent de	5 != 3 renvoie true
!==	Différent strict	5 !== "5" renvoie true
>	Supérieur à	5 > 3 renvoie true
<	Inférieur à	5 < 3 renvoie false
>=	Supérieur ou égal à	5 >= 5 renvoie true
<=	Inférieur ou égal à	5 <= 3 renvoie false

Voyons-les en action :

let x = 5;
let y = "5";

console.log(x == y);  // Output: true
console.log(x === y); // Output: false
console.log(x != y);  // Output: false
console.log(x !== y); // Output: true
console.log(x > 3);   // Output: true
console.log(x < 10);  // Output: true
console.log(x >= 5);  // Output: true
console.log(x <= 4);  // Output: false

Note la différence entre == et ===. Le triple égal (===) vérifie à la fois la valeur et le type, tandis que le double égal (==) vérifie uniquement la valeur. C'est une source courante de bugs pour les débutants, alors sois toujours attentif à celui que tu utilises !

Opérateurs Logiques JavaScript

Les opérateurs logiques sont les décideurs en JavaScript. Ils vous aident à combiner plusieurs conditions et à prendre des décisions complexes. Pensez-les comme les sages du village de programmation, guidant votre code pour faire les bons choix.

Voici un tableau des opérateurs logiques :

Opérateur	Description	Exemple
&&	ET logique	(x > 0 && x < 10)
||	OU logique	(x === 5 || y === 5)
!	NON logique	!(x === y)

Voyons-les en action :

let a = 5;
let b = 10;

console.log(a > 0 && b < 20);  // Output: true
console.log(a > 10 || b === 10);  // Output: true
console.log(!(a === b));  // Output: true

L'opérateur && renvoie vrai uniquement si les deux conditions sont vraies. L'opérateur || renvoie vrai si au moins une des conditions est vraie. L'opérateur ! inverse la valeur booléenne - il transforme vrai en faux et faux en vrai.

Opérateurs Bitwise JavaScript

Nous entrons maintenant dans le domaine des opérateurs bitwise. Ces opérateurs travaillent sur les bits des valeurs entières. Ils sont comme les agents secrets du monde de la programmation - pas utilisés souvent, mais incroyablement puissants quand ils le sont nécessaires.

Voici un tableau des opérateurs bitwise :

Opérateur	Description
&	ET bitwise
|	OU bitwise
^	OU exclusif bitwise
~	NON bitwise
<<	Décalage à gauche
>>	Décalage à droite signé
>>>	Décalage à droite avec remplissage de zéros

Ces opérateurs sont un peu avancés, donc ne t'inquiète pas si ils semblent confus au début. Comme tu progresses dans ton parcours JavaScript, tu rencontreras des situations où ils seront utiles.

Opérateurs d'Affectation JavaScript

Les opérateurs d'affectation sont utilisés pour assigner des valeurs à des variables. Ils sont comme les déménageurs du monde de la programmation - ils mettent les choses à leur place.

Voici un tableau des opérateurs d'affectation :

Opérateur	Description	Exemple
=	Affectation	x = 5
+=	Addition affectation	x += 3 est équivalent à x = x + 3
-=	Soustraction affectation	x -= 3 est équivalent à x = x - 3
*=	Multiplication affectation	x = 3 est équivalent à x = x 3
/=	Division affectation	x /= 3 est équivalent à x = x / 3
%=	Modulo affectation	x %= 3 est équivalent à x = x % 3

Voyons-les en action :

let x = 5;
console.log(x); // Output: 5

x += 3;
console.log(x); // Output: 8

x -= 2;
console.log(x); // Output: 6

x *= 4;
console.log(x); // Output: 24

x /= 3;
console.log(x); // Output: 8

x %= 3;
console.log(x); // Output: 2

Ces opérateurs sont des raccourcis qui rendent votre code plus concis et lisible. Ils sont comme les couteaux suisses du monde de la programmation - polyvalents et pratiques !

Opérateurs Divers JavaScript

Enfin, regardons quelques opérateurs qui ne rentrent pas dans les autres catégories.

1. Opérateur Conditionnel (Ternaire) : C'est un raccourci pour une instruction if-else.

let age = 20;
let canVote = (age >= 18) ? "Oui" : "Non";
console.log(canVote); // Output: "Oui"

Cet opérateur vérifie si age >= 18 est vrai. Si c'est le cas, il affecte "Oui" à canVote, sinon il affecte "Non".

2. Opérateur typeof : Cela renvoie une chaîne indiquant le type de l'opérande.

console.log(typeof 42);        // Output: "number"
console.log(typeof 'blubber'); // Output: "string"
console.log(typeof true);      // Output: "boolean"
console.log(typeof [1, 2, 4]); // Output: "object"

3. Opérateur delete : Cela supprime la propriété d'un objet ou un élément d'un tableau.

let person = {name: "John", age: 30};
delete person.age;
console.log(person); // Output: {name: "John"}

Et voilà, les amis ! Nous avons parcouru le territoire des opérateurs JavaScript. Souviens-toi, la pratique rend parfait. Alors, n'ayez pas peur d'expérimenter avec ces opérateurs dans votre propre code. Bonne programmation !

Credits: Image by storyset