Opérateurs en TypeScript

Cet article explique les opérateurs en TypeScript.

YouTube Video

Opérateurs en TypeScript

Les opérateurs en TypeScript sont utilisés pour effectuer des calculs numériques, des comparaisons de valeurs et des opérations logiques. Comme TypeScript utilise des opérateurs similaires à JavaScript, ils sont faciles à appréhender, mais TypeScript permet des opérations plus rigoureuses grâce à la sécurité des types.

Les principaux opérateurs sont les suivants :.

Opérateurs arithmétiques

Les opérateurs arithmétiques sont utilisés pour les calculs numériques.

 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);

Opérateurs d'affectation

Les opérateurs d'affectation attribuent la valeur à droite à la variable située à gauche.

1let z = 5;
2z += 3;
3console.log(z);  // Outputs: 8
4
5z *= 2;
6console.log(z);  // Outputs: 16

Opérateurs de comparaison

Les opérateurs de comparaison comparent les valeurs et renvoient true ou false.

1console.log('5 == "5"   :', 5 == "5");   // Outputs: true
2console.log('5 === "5"  :', 5 === "5");  // Outputs: false
3console.log('5 != "5"   :', 5 != "5");   // Outputs: false
4console.log('5 !== "5"  :', 5 !== "5");  // Outputs: true
5console.log('5 > 3      :', 5 > 3);      // Outputs: true
6console.log('5 < 3      :', 5 < 3);      // Outputs: false
7console.log('5 >= 5     :', 5 >= 5);     // Outputs: true
8console.log('5 <= 3     :', 5 <= 3);     // Outputs: false

Opérateurs logiques

Les opérateurs logiques sont utilisés pour combiner des expressions logiques.

1console.log('true && false :', true && false);  // Outputs: false
2console.log('true || false :', true || false);  // Outputs: true
3console.log('!true         :', !true);          // Outputs: false

Précedence des opérateurs logiques

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

NOT a la priorité la plus élevée

NOT est un opérateur unaire et il est évalué avec la priorité la plus élevée.

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

En conséquence, la partie AND (&&) est calculée en premier, et son résultat est passé à OR (||).

AND et OR effectuent une évaluation en court-circuit

En TypeScript, AND et OR effectuent une évaluation en court-circuit. Si le résultat est déterminé par la valeur de gauche, l'expression de droite 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 les deux cas, console.log() n'est pas exécuté.

Définir explicitement la priorité

Utiliser des parenthèses pour regrouper explicitement des expressions peut éviter des malentendus sur la priorité.

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

Différences entre le langage naturel et l'interprétation du programme

Lors de l'utilisation des opérateurs logiques, il est important d'être conscient des ambiguïtés du langage naturel. Par exemple, dans la phrase « un chien blanc ou un chat », cela pourrait signifier soit « un chien blanc ou n'importe quel chat », soit « un chien blanc ou un chat blanc ». En code, cela peut s'écrire comme suit :.

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}

Comme le langage naturel peut être ambigu, il est nécessaire d'être prudent lors de la programmation et de la conception de systèmes.

Opérateurs binaires

Les opérateurs binaires manipulent les nombres au niveau des bits.

1console.log('5 & 1  :', 5 & 1);   // Outputs: 1  (AND operation)
2console.log('5 | 1  :', 5 | 1);   // Outputs: 5  (OR operation)
3console.log('5 ^ 1  :', 5 ^ 1);   // Outputs: 4  (XOR operation)
4console.log('~5     :', ~5);      // Outputs: -6 (NOT operation)
5console.log('5 << 1 :', 5 << 1);  // Outputs: 10 (Left shift operation)
6console.log('5 >> 1 :', 5 >> 1);  // Outputs: 2  (Right shift operation)
7console.log('5 >>> 1:', 5 >>> 1); // Outputs: 2  (Unsigned right shift operation)

Opérateur Tertiaire

L'opérateur tertiaire renvoie des valeurs différentes en fonction du résultat d'une expression conditionnelle.

1let age = 20;
2let access = (age >= 18) ? "Allowed" : "Denied";
3console.log(access);  // Outputs: Allowed

Opérateurs de type

Les opérateurs de type de TypeScript incluent les suivants :.

 1console.log(typeof "Hello");  // "string"
 2console.log(typeof 42);       // "number"
 3
 4let arr: number[] = [1, 2, 3];
 5console.log("arr instanceof Array : ", arr instanceof Array); // true
 6
 7// Example of Type Guard
 8function isString(value: any): value is string {
 9  return typeof value === "string";
10}
11
12let value: any = "Hello";
13if (isString(value)) {
14  console.log("Value is a string:", value);  // "Value is a string: Hello"
15}

Les opérateurs de type sont utilisés pour vérifier le type d'une valeur ou 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.
• L'opérateur is est utilisé pour vérifier si une valeur est d'un type spécifique. Il fait partie des gardes de type de TypeScript.

Résumé

• Opérateurs Arithmétiques : Effectuent des calculs de base.
• Opérateurs d'Affection : Attribuent des valeurs aux variables.
• Opérateurs de Comparaison : Comparent des valeurs.
• Opérateurs Logiques : Combinent des conditions logiques.
• Opérateurs au Niveau des Bits : Effectuent des opérations au niveau binaire.
• Opérateur Tertiaire : Renvoie des valeurs selon des conditions.
• Les opérateurs de type peuvent vérifier le type d'une valeur.

En TypeScript, ces opérateurs peuvent être utilisés pour écrire des calculs complexes et des expressions conditionnelles de manière efficace.

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