Les opérateurs

Tout comme la plupart des langages de programmation, JavaScript possède différents opérateurs. Nous allons les passer en revue et voir comment les utiliser.
Les opérateurs sont des symboles qui permettent de manipuler des variables, c'est-à-dire d'effectuer des opérations, de les évaluer...

Avant d'aller plus loin, il faut bien comprendre ce qu'est un "opérande" ?. Outch... ça commence !
Un opérande est la partie qui représente la donnée manipulée par l'opérateur.

Un exemple :

8 + 4

Le signe plus + est un opérateur alors que les nombres 8 et 4 sont des opérandes.
Un rappel est toujours bienvenu.

Les opérateurs unaires et binaires

Il existe deux types d'opérateurs, les unaires et les binaires :

• Les unaires : ils n'agissent que sur un opérande,
• Les binaires : ils agissent sur deux opérandes.

Les opérateurs de calcul

Comme leur nom l'indique, les opérateurs de calcul permettent de modifier mathématiquement la valeur d'une variable :

/**
 * Opérateur d'addition "+"
 * Ajoute deux valeurs
 * ---
 * Résultat = 10
 */
let total = 7+3;

/**
 * Opérateur de soustraction "-"
 * Soustrait deux valeurs
 * ---
 * Résultat = 4
 */
let total = 7-3;

/**
 * Opérateur de multiplication "*"
 * Multiplie deux valeurs
 * ---
 * Résultat = 21
 */
let total = 7*3;

/**
 * Opérateur de division "/"
 * Divise deux valeurs
 * ---
 * Résultat = 2.33
 */
let total = 7/3;

/**
 * Opérateur d'affectation "="
 * Affecte une valeur à une variable
 * ---
 * Résultat = 3
 */
let total = 3;

/**
 * Opérateur modulo "%"
 * Retourne le reste de la division entière de l'opérande
 * de gauche par celle de droite
 * ---
 * Résultat = 1
 */
let total = 7%3;

Les opérateurs d'affectation

Ces opérateurs permettent d'effectuer les mêmes opérations que les opérateurs de calculs, mais de manière plus simple.

La variable de gauche, affectée d'un nombre, se verra affectée d'une nouvelle valeur selon l'opérateur utilisé :

let total = 7;

/**
 * Opérateur d'addition "+="
 * Résultat = 10
 */
let total += 3;

/**
 * Opérateur de soustraction "-="
 * Résultat = 4
 */
let total -= 3;

/**
 * Opérateur de multiplication "*="
 * Résultat = 21
 */
let total *= 3;

/**
 * Opérateur de division "/="
 * Résultat = 2.33
 */
let total /= 3;

/**
 * Opérateur modulo "%="
 * Résultat = 1
 */
let total %= 3;

Les opérateurs d'incrémentation

Ils nous aident à facilement augmenter ou diminuer d'une unité une variable de type Number.
Ces opérateurs sont très utiles lors de l'utilisation, par exemple, d'une boucle. Ils se placent après l'opérande et sans ajout d'espace :

let total = 7;

/**
 * Incrémentation "++"
 * Résultat = 8
 */
let total++;

/**
 * Décrémentation "--"
 * Résultat = 6
 */
let total--;

Les opérateurs de comparaisons

Ce sont les plus utilisés dans la programmation. Ils permettent d'effectuer toutes sortes de comparaison afin de vérifier si un résultat est conforme à notre attente ou non.

Les comparaisons s'effectuent toujours entre deux valeurs : on compare la valeur de gauche à celle de droite. La valeur de retour sera un booléen soit true ou false :

let a = 10;
let b = 20;

/**
 * Opérateur d'égalité "=="
 * Vérifie si les valeurs sont identiques
 * A NE PAS CONFONDRE AVEC LE ÉGAL "=" QUI EST UN SIGNE D'AFFECTATION
 */
console.log(a == b); // false

/**
 * Opérateur d'identité "==="
 * Vérifie si les valeurs et les types sont identiques
 */
console.log(a === b); // false

/**
 * Opérateur de différence "!="
 * Vérifie si les valeurs sont différentes
 */
console.log(a != b); // true

/**
 * Opérateur de non identité "!=="
 * Vérifie si les valeurs et les types sont différents
 */
console.log(a !== b); // true

/**
 * Opérateur d'infériorité stricte "<"
 * Vérifie si une valeur est strictement inférieure à une autre valeur
 */
console.log(a < b); // true

/**
 * Opérateur d'infériorité "<="
 * Vérifie si une valeur est inférieure ou égale à une autre valeur
 */
console.log(a <= b); // true

/**
 * Opérateur de supériorité stricte ">"
 * Vérifie si une valeur est strictement supérieure à une autre valeur
 */
console.log(a > b); // false

/**
 * Opérateur de supériorité ">="
 * Vérifie si une valeur est supérieure ou égale à une autre valeur
 */
console.log(a >= b); // false

Les opérateurs d'égalité, d'identité, de différence et non-identité peuvent aussi être utilisés avec des chaines de caractères :

let firstname = "john";
let lastname = "smith";

console.log(firstname == lastname); // false
console.log(firstname === lastname); // false
console.log(firstname != lastname); // true
console.log(firstname !== lastname); // true

Les opérateurs logiques

Ces opérateurs permettent quant à eux de vérifier si plusieurs conditions sont vraies :

/**
 * Opérateur OU logique "||"
 * Vérifie qu'une des conditions est vraie
 */
console.log(expression1 || expression2);

/**
 * Opérateur ET logique "&&"
 * Vérifie que toutes les conditions sont vraies 
 */
console.log(expression1 && expression2);

/**
 * Opérateur non logique "!"
 * Inverse l'état d'une variable booléenne
 */
console.log(!false); // true
console.log(!true); // false

L'opérateur de coalescence nulle

C'est un opérateur logique qui affectera la valeur de droite si jamais la valeur de gauche est à null ou undefined.

let maVariable = null;
let monAutreVariable = 43;

let y = maVariable ?? "Vide !"; // Vide !
let x = monAutreVariable ?? 0;  // 43