Cours IT Bases JavaScript 040_Opérateurs

Les opérateurs JavaScript sont utilisés pour effectuer des opérations mathématiques, des comparaisons, des opérations logiques et d’autres opérations, et renvoient des résultats.

Opérateurs arithmétiques

• + : Addition
• - : Soustraction
• * : Multiplication
• / : Division
• % : Modulo (reste)
• ** : Exponentiation

Exemple :

1
let a = 5;
2
let b = 2;
3

4
console.log(a + b);  // Sortie 7
5
console.log(a - b);  // Sortie 3
6
console.log(a * b);  // Sortie 10
7
console.log(a / b);  // Sortie 2.5
8
console.log(a % b);  // Sortie 1
9
console.log(a**b);  // Sortie 25

Opérateurs d’affectation

• = : Affectation
• += : Affectation d’addition
• -= : Affectation de soustraction
• *= : Affectation de multiplication
• /= : Affectation de division
• %= : Affectation de modulo
• **= : Affectation d’exponentiation
• ??= : Affectation nullish, l’affectation ne se produit que lorsque la valeur de la variable est null ou undefined

Exemple :

1
let x = 5;
2
x += 2;  // x = x + 2; Sortie 7
3
x -= 2;  // x = x - 2; Sortie 3
4
x *= 2;  // x = x * 2; Sortie 10
5
x /= 2;  // x = x / 2; Sortie 2.5
6
x %= 2;  // x = x % 2; Sortie 1
7
x **= 2;  // x = x ** 2; Sortie 25
8
x ??= 2;  // Sortie 5, affecte 2 lorsque x est null ou undefined
9
console.log(x);

Opérateurs de comparaison

• == : Égalité (le type de valeur est automatiquement converti)
• === : Égalité stricte (valeur et type sont égaux)
• != : Inégalité
• !== : Inégalité stricte
• > : Supérieur à
• < : Inférieur à
• >= : Supérieur ou égal à
• <= : Inférieur ou égal à

Lorsque des valeurs non numériques sont rencontrées, elles sont d’abord converties en valeurs numériques puis comparées. Lorsque des chaînes sont rencontrées, les codes Unicode des caractères sont comparés position par position.

Exemple :

1
let a = 5;
2
let b = '5';
3
let c = 10;
4

5
console.log(a == b);   // Sortie true, les valeurs sont égales
6
console.log(a === b);  // Sortie false, les types ne sont pas égaux
7
console.log(a != b);   // Sortie false, les valeurs sont égales
8
console.log(a !== b);  // Sortie true, les types ne sont pas égaux
9
console.log(a > c);  // Sortie false, 5 < 10
10
console.log(a < c);  // Sortie true, 5 < 10
11
console.log(a >= c);  // Sortie false, 5 <= 10
12
console.log(a <= c);  // Sortie true, 5 <= 10

Opérateurs logiques

Les opérateurs logiques, lors du traitement des opérandes, les convertissent en valeurs booléennes et renvoient la valeur d’origine de cet opérande.

&& : ET logique

Utilisé pour vérifier si toutes les conditions sont true simultanément. Si toutes les conditions sont true, le résultat de l’expression entière est true ; sinon, le résultat est false. L’opération ET recherche le premier false de gauche à droite. Si false est trouvé, le calcul s’arrête et renvoie la valeur d’origine de cet opérande (évaluation en court-circuit). S’il n’y a finalement pas de false, le dernier true est renvoyé.

|| : OU logique

Utilisé pour vérifier si au moins une condition est true. Si au moins une condition est true, le résultat de l’expression entière est true ; si toutes les conditions sont false, le résultat est false. L’opération OU recherche le premier true de gauche à droite. Si true est trouvé, le calcul s’arrête et renvoie la valeur d’origine de cet opérande (évaluation en court-circuit). S’il n’y a finalement pas de true, le dernier false est renvoyé.

! : NON logique

Utilisé pour inverser une valeur booléenne. Si une valeur est true, l’utilisation de l’opérateur NON logique l’inverse en false ; si une valeur est false, elle l’inverse en true. Le NON logique peut également être utilisé pour convertir des valeurs non booléennes en valeurs booléennes. Il convertit toutes les valeurs sauf null, undefined, 0, NaN, "" (chaîne vide) en true, tandis que ces valeurs elles-mêmes sont converties en false.

Exemple :

1
let a = true;
2
let b = false;
3
let c = "hello";
4
let d = null;
5

6
console.log(a && b);  // Sortie false
7
console.log(c && d);  // Sortie null
8
console.log(a || b);  // Sortie true
9
console.log(c || d);  // Sortie hello
10
console.log(!a);      // Sortie false
11
console.log(!d);      // Sortie true

Opérateur ternaire

• condition ? expr1 : expr2 : Si la condition est vraie, renvoie expr1, sinon renvoie expr2.

Exemple :

1
let age = 18;
2
let status = (age >= 18) ? 'Adulte' : 'Mineur';
3
console.log(status);  // Sortie 'Adulte'

Opérateur de coalescence nulle

L’opérateur de coalescence nulle (Nullish Coalescing Operator) est un opérateur utilisé pour gérer les valeurs par défaut, généralement utilisé pour garantir qu’une variable a une valeur non nulle (ni null ni undefined). La syntaxe de cet opérateur est ??.

Lors de l’utilisation de l’opérateur de coalescence nulle, il renvoie le premier opérande défini (ni null ni undefined). Si le premier opérande est null ou undefined, il renvoie le deuxième opérande.

Exemple :

1
let num1 = 0;
2
let num2 = 1;
3
let result = num1 ?? num2;
4
console.log(result);  // Sortie 0, car num n'est pas null ou undefined
5

6
let user;
7
console.log(user ?? "Anonyme"); // Sortie Anonyme, car user n'est pas défini

Opérateurs au niveau du bit

• & : ET au niveau du bit
• | : OU au niveau du bit
• ^ : XOR au niveau du bit
• ~ : NON au niveau du bit
• << : Décalage à gauche
• >> : Décalage à droite
• >>> : Décalage à droite non signé

Exemple :

1
let a = 5;  // Binaire : 0101
2
let b = 3;  // Binaire : 0011
3

4
console.log(a & b);   // Sortie 1 (ET au niveau du bit)
5
console.log(a | b);   // Sortie 7 (OU au niveau du bit)
6
console.log(a ^ b);   // Sortie 6 (XOR au niveau du bit)
7
console.log(~a);      // Sortie -6 (NON au niveau du bit)
8
console.log(a << 1);  // Sortie 10 (Décalage à gauche)
9
console.log(a >> 1);  // Sortie 2 (Décalage à droite)

Autres opérateurs

• typeof : Renvoie une chaîne indiquant le type de l’opérande non évalué.
• instanceof : Utilisé pour tester si un objet est une instance d’un type spécifique.

Exemple :

1
let str = 'Hello';
2
console.log(typeof str);  // Sortie 'string'
3

4
let arr = [1, 2, 3];
5
console.log(arr instanceof Array);  // Sortie true

+ (Plus)

En JavaScript, le signe plus + a plusieurs utilisations, y compris les opérations mathématiques, la concaténation de chaînes et les opérations unaires.

Opération mathématique

Exemple :

1
let a = 5;
2
let b = 3;
3
let result = a + b;
4
console.log(result);  // Sortie 8

Si les deux sont des nombres, + est utilisé pour effectuer une addition mathématique.

Concaténation de chaînes

Exemple :

1
let str1 = 'Hello';
2
let str2 = ' World';
3
let result = str1 + str2;
4
console.log(result);  // Sortie 'Hello World'

Si l’un des opérandes est une chaîne, + effectuera une concaténation de chaînes.

Opérateur plus unaire

Exemple :

1
let str = '42';
2
let num = +str;
3
console.log(num);  // Sortie 42

En utilisant + devant un seul opérande, il peut convertir l’opérande en nombre. C’est la fonction de l’opérateur plus unaire.

Conversion de type

Exemple :

1
let num = 42;
2
let str = '10';
3
let result = num + str;  // Conversion de type implicite (coercition de type)
4
console.log(result);  // Sortie '4210'

Si l’un des opérandes est une chaîne, + effectuera une conversion de type, convertissant les autres opérandes en chaînes, puis effectuera une concaténation de chaînes.

Concaténation de tableaux

Exemple :

1
let arr1 = [1, 2, 3];
2
let arr2 = [4, 5, 6];
3
let result = arr1 + arr2;
4
console.log(result);  // Sortie '1,2,34,5,6'

Lorsqu’un opérande est un tableau, + convertira le tableau en chaîne, puis effectuera une concaténation de chaînes.

Cas particuliers

Exemple :

1
let specialResult1 = '1' + 2 + 3;
2
console.log(specialResult1);  // Sortie '123'
3

4
let specialResult2 =  2 + 3 + '1';
5
console.log(specialResult2);  // Sortie '51'

specialResult1 : Parce que la chaîne apparaît à l’extrême gauche de +, les nombres suivants seront concaténés comme des chaînes. specialResult2 : Parce que la chaîne apparaît à l’extrême droite de +, les nombres précédents seront d’abord additionnés mathématiquement, puis concaténés.

- (Moins)

En JavaScript, le signe moins - est un opérateur utilisé pour effectuer une soustraction mathématique.

Soustraction mathématique

Exemple :

1
let a = 5;
2
let b = 3;
3
let result = a - b;
4
console.log(result);  // Sortie 2

Si les deux sont des nombres, - est utilisé pour effectuer une soustraction mathématique.

Opérateur moins unaire

Exemple :

1
let num = 42;
2
let result = -num;
3
console.log(result);  // Sortie -42

En utilisant - devant un seul opérande, il peut effectuer une soustraction unaire, convertissant l’opérande en son opposé.

Conversion de type

Exemple :

1
let num1 = 42;
2
let str = '10';
3
let result = num1 - str;
4
console.log(result);  // Sortie 32

Si l’un des opérandes est une chaîne, - effectuera une conversion de type, convertissant les autres opérandes en nombres, puis effectuera une soustraction mathématique.

Cas particulier

Exemple :

1
let specialResult = '10' - 2;
2
console.log(specialResult);  // Sortie 8

Dans ce cas particulier, étant donné que le contenu de la chaîne peut être converti avec succès en nombre, - effectuera une soustraction mathématique.

=、==、=== (Affectation, égalité non stricte, égalité stricte)

En JavaScript, le signe égal = est un opérateur d’affectation, tandis que == et === sont des opérateurs de comparaison. L’égalité non stricte convertit les deux opérandes au même type, puis effectue la comparaison. Dans les vérifications conditionnelles, === est généralement utilisé pour les comparaisons d’égalité stricte car il n’effectue pas de conversion de type.

Opérateur d’affectation

= est utilisé pour affecter la valeur du côté droit à la variable du côté gauche.

Exemple :

1
let x = 5;
2
let y = 'Hello';
3
console.log(x);  // Sortie 5
4
console.log(y);  // Sortie 'Hello'

Dans cet exemple, = affecte la valeur du côté droit aux variables x et y du côté gauche.

Opérateurs de comparaison

== et === sont utilisés pour comparer l’égalité de deux valeurs.

Exemple :

1
let a = 5;
2
let b = '5';
3

4
console.log(a == b);   // Sortie true
5
console.log(a === b);  // Sortie false

Lors des comparaisons d’égalité avec ==, une conversion de type est effectuée, null == undefined donne true. Lors des comparaisons d’égalité avec ===, la valeur et le type doivent être égaux, null === undefined donne false. NaN n’est pas égal à aucune valeur, y compris NaN lui-même.

++、-- (Incrémentation, Décrémentation)

En JavaScript, l’incrémentation (++) et la décrémentation (--) sont des opérateurs utilisés pour augmenter ou diminuer la valeur d’une variable.

Opérateur d’incrémentation (++)

Après utilisation, la variable d’origine augmentera immédiatement de 1. Incrémentation préfixe renvoie la valeur après incrémentation (nouvelle valeur) ; Incrémentation suffixe renvoie la valeur avant incrémentation (ancienne valeur) ;

Exemple d’incrémentation préfixe :

1
let a = 5;
2
// Incrémentation préfixe, d'abord augmente de 1, puis utilise la nouvelle valeur
3
let b = ++a;
4
console.log(b);  // Sortie 6
5
console.log(a);  // Sortie 6

Dans cet exemple, a a d’abord augmenté de 1, puis b a obtenu la nouvelle valeur de a (6).

Exemple d’incrémentation suffixe :

1
let x = 5;
2
// Incrémentation suffixe, d'abord utilise la valeur actuelle, puis augmente de 1
3
let y = x++;
4
console.log(y);  // Sortie 5
5
console.log(x);  // Sortie 6

Dans cet exemple, y a d’abord obtenu la valeur actuelle de x (5), puis la valeur de x a augmenté de 1.

Opérateur de décrémentation (—)

Après utilisation, la variable d’origine diminuera immédiatement de 1. Décrémentation préfixe renvoie la valeur après décrémentation (nouvelle valeur) ; Décrémentation suffixe renvoie la valeur avant décrémentation (ancienne valeur) ;

Exemple de décrémentation préfixe :

1
let p = 10;
2
// Décrémentation préfixe, d'abord diminue de 1, puis utilise la nouvelle valeur
3
let q = --p;
4
console.log(q);  // Sortie 9
5
console.log(p);  // Sortie 9

Dans cet exemple, p a d’abord diminué de 1, puis q a obtenu la nouvelle valeur de p (9).

Exemple de décrémentation suffixe :

1
let m = 8;
2
// Décrémentation suffixe, d'abord utilise la valeur actuelle, puis diminue de 1
3
let n = m--;
4
console.log(n);  // Sortie 8
5
console.log(m);  // Sortie 7

Dans cet exemple, n a d’abord obtenu la valeur actuelle de m (8), puis la valeur de m a diminué de 1.

Priorité des opérateurs :

https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Operators/Operator_precedence