Les opérateurs en JavaScript

Dans cet article, nous expliquerons les opérateurs en JavaScript.

YouTube Video

Les opérateurs en JavaScript

Les opérateurs en JavaScript sont des symboles ou mots-clés utilisés pour effectuer des calculs ou des comparaisons sur des nombres et des variables. Il existe différents types d'opérateurs, chacun effectuant des opérations distinctes. Voici un résumé de certains des principaux opérateurs :.

Opérateurs arithmétiques

Les opérateurs arithmétiques de JavaScript incluent les suivants :.

 1let a = 10; // Initialize variable 'a' with the value 10
 2let b = 3;  // Initialize variable 'b' with the value 3
 3
 4// Perform and display arithmetic operations between 'a' and 'b'
 5console.log("Addition (a + b):      ", a + b); // 13
 6console.log("Subtraction (a - b):   ", a - b); // 7
 7console.log("Multiplication (a * b):", a * b); // 30
 8console.log("Division (a / b):      ", a / b); // 3.333...
 9console.log("Modulus (a % b):       ", a % b); // 1
10
11// Demonstrate post-increment operation on 'a'
12// Output the current value of 'a' (10), then increment
13console.log("Post-increment (a++):  ", a++);
14// Display the incremented value of 'a' (11)
15console.log("Value of 'a' after increment:", a);
16
17// Demonstrate pre-increment operation on 'a'
18// Increment 'a' first (12) then output
19console.log("Pre-increment (++a):   ", ++a);
20
21// Demonstrate post-decrement operation on 'a'
22// Output the current value of 'a' (12), then decrement
23console.log("Post-decrement (a--):  ", a--);
24// Display the decremented value of 'a' (11)
25console.log("Value of 'a' after decrement:", a);
26
27// Demonstrate pre-decrement operation on 'a'
28// Decrement 'a' first (10) then output
29console.log("Pre-decrement (--a):   ", --a);

Les opérateurs arithmétiques effectuent des opérations mathématiques de base sur les nombres. En plus de l'addition et de la soustraction, vous pouvez effectuer des opérations telles que le module, l'incrémentation et la décrémentation. Notez que la valeur renvoyée par l'incrémentation ou la décrémentation diffère selon que l'opérateur est placé avant ou après l'opérande.

Opérateurs d'affectation

Les opérateurs d'affectation de JavaScript incluent les suivants :.

 1let x = 10;
 2
 3x += 5;  // x = x + 5, so x becomes 15
 4console.log('After x += 5 : ', x);  // 15
 5
 6x -= 10;
 7console.log('After x -= 10 : ', x);  // 5
 8
 9x *= 3;
10console.log('After x *= 3 : ', x);  // 15
11
12x /= 3;
13console.log('After x /= 3 : ', x);  // 5
14
15x %= 2;
16console.log('After x %= 2 : ', x);  // 1

Les opérateurs d'affectation sont utilisés pour attribuer des valeurs aux variables ou pour mettre à jour les valeurs des variables. En plus de l'affectation classique, il existe des opérateurs d'affectation pour des opérations arithmétiques comme l'addition et le modulo.

Opérateurs de comparaison

Les opérateurs de comparaison de JavaScript incluent les suivants :.

 1console.log("5 == '5' evaluates to:", 5 == "5");   // true (because the values are equal)
 2console.log("5 === '5' evaluates to:", 5 === "5"); // false (because the types are different)
 3console.log("5 != '5' evaluates to:", 5 != "5");   // false
 4console.log("5 !== '5' evaluates to:", 5 !== "5"); // true
 5console.log("5 > 2 evaluates to:", 5 > 2);         // true
 6console.log("5 < 2 evaluates to:", 5 < 2);         // false
 7console.log("5 >= 5 evaluates to:", 5 >= 5);       // true
 8console.log("5 <= 4 evaluates to:", 5 <= 4);       // false
 9console.log("5 >= '5' evaluates to:", 5 >= "5");   // true
10console.log("5 <= '5' evaluates to:", 5 <= "5");   // true

• Les opérateurs de comparaison comparent les valeurs et renvoient soit vrai, soit faux.
• L'opérateur d'égalité (==) convertit automatiquement les types différents si nécessaire avant d'effectuer la comparaison. L'opérateur d'égalité stricte (===) ne réalise aucune conversion de type lors de la comparaison et renvoie true uniquement si les deux valeurs ont le même type et la même valeur. Utiliser l'opérateur d'égalité stricte (===) aide à prévenir les bugs causés par des conversions de type involontaires, il est donc recommandé de l'utiliser en priorité.

Opérateurs logiques

Les opérateurs logiques de JavaScript incluent les suivants :.

1let a = true;
2let b = false;
3
4console.log("a && b evaluates to:", a && b);  // false
5console.log("a || b evaluates to:", a || b);  // true
6console.log("!a evaluates to:", !a);          // false

Les opérateurs logiques sont utilisés lorsqu'il y a plusieurs conditions, pour évaluer des combinaisons de conditions.

Priorité des opérateurs logiques

En JavaScript, les opérateurs logiques sont généralement évalués dans l'ordre suivant : NOT d'abord, suivi de AND, et enfin OR.

NOT a la priorité la plus élevée

NOT est un opérateur unaire et est évalué avec la plus haute priorité.

1console.log(!true || false);  // false

AND a la priorité sur OR

AND a une priorité plus élevée que OR, donc la partie AND est évaluée en premier.

1console.log(true || false && false);  // true

De cette manière, la partie AND (&&) est évaluée en premier, et son résultat est transmis à OR (||).

AND et OR effectuent une évaluation en court-circuit

AND et OR en JavaScript effectuent une évaluation en court-circuit. Si le résultat peut être déterminé par la valeur du côté gauche, l'expression du côté droit n'est pas évaluée.

1let a = false && console.log("This will not be printed");
2console.log(a);  // false
3
4let b = true || console.log("This will not be printed");
5console.log(b);  // true

Dans tous les cas, console.log() ne sera pas exécuté.

Établir une priorité explicite

En regroupant explicitement les expressions avec des parenthèses, vous pouvez éviter les malentendus concernant la priorité.

1console.log(true || (false && false));  // true

Différences entre le langage naturel et l'interprétation des programmes

Lorsque vous utilisez des opérateurs logiques, il est important de tenir compte des ambiguïtés du langage naturel. Par exemple, lorsqu'on dit 'chien blanc ou chat', cela peut signifier soit 'un chien blanc ou un chat de n'importe quelle couleur', soit 'un chien blanc ou un chat blanc'. En code, cela ressemblerait à ceci :.

1if (isWhite && isDog || isCat) {
2    console.log(' "A white dog" or "a cat of any color" ');
3}
4
5if (isWhite && (isDog || isCat)) {
6    console.log(' "A white dog" or "a white cat" ');
7}
8
9console.log(true || (false && false));  // true

Comme le langage naturel contient des ambiguïtés de ce type, il faut être prudent lors de la programmation ou de la conception.

Opérateur ternaire (Opérateur conditionnel)

JavaScript inclut un opérateur ternaire (opérateur conditionnel).

1let age = 20;
2let message = age >= 18 ? "Adult" : "Minor";
3console.log(message);  // "Adult"

Il s'écrit sous la forme condition ? valeur si vrai : valeur si faux.

Opérateurs au niveau des bits

Les opérateurs binaires de JavaScript incluent les suivants.

 1let x = 0x0F & 0x0C;
 2console.log("0x0F & 0x0C evaluates to:", x, "(0x0C, 12)");  // 0x0C (12)
 3
 4x = 0x04 | 0x02;
 5console.log("0x04 | 0x02 evaluates to:", x, "(0x06, 6)");  // 0x06 (6)
 6
 7x = 0x0F ^ 0x0C;
 8console.log("0x0F ^ 0x0C evaluates to:", x, "(0x03, 3)");  // 0x03 (3)
 9
10// The inverted number is represented as a negative value
11// because JavaScript numbers are stored as signed 32-bit integers.
12x = ~0x0C;
13console.log("~0x0C evaluates to:", x, "(-13, 0xF3)");  // 0xF3 (-13)
14
15x = 0x04 << 1;
16console.log("0x04 << 1 evaluates to:", x, "(0x08, 8)");    // 0x08 (8)
17x = 0x04 >> 1;
18console.log("0x04 >> 1 evaluates to:", x, "(0x02, 2)");    // 0x02 (2)

Les opérateurs binaires effectuent des calculs sur les nombres au niveau des bits. Ils sont généralement utilisés pour le traitement de bas niveau.

Opérateurs de type

Les opérateurs de type de JavaScript incluent les suivants.

1console.log(typeof "Hello");  // "string"
2console.log(typeof 42);       // "number"
3
4let arr = [1, 2, 3];
5console.log("arr instanceof Array : ", arr instanceof Array); // true

Les opérateurs de type sont utilisés pour vérifier le type d'une valeur ou pour la convertir en un type spécifique.

L'opérateur typeof renvoie le type d'une variable.

L'opérateur instanceof vérifie si un objet appartient à une classe spécifique.

Résumé

• Les opérateurs arithmétiques effectuent des calculs de base.
• Les opérateurs d’affectation attribuent ou mettent à jour les valeurs dans les variables.
• Les opérateurs de comparaison comparent deux valeurs et renvoient vrai ou faux.
• Les opérateurs logiques évaluent des combinaisons de conditions.
• Les opérateurs ternaires permettent d'écrire des instructions conditionnelles sous une forme plus courte que if.
• Les opérateurs binaires effectuent des calculs au niveau des bits.
• Les opérateurs de type permettent de vérifier le type d'une valeur.

Vous pouvez suivre l'article ci-dessus avec Visual Studio Code sur notre chaîne YouTube. Veuillez également consulter la chaîne YouTube.

YouTube Video