Instructions conditionnelles en TypeScript

Dans cet article, nous expliquerons les instructions conditionnelles en TypeScript.

YouTube Video

Les instructions if en TypeScript

En TypeScript, une instruction if effectue une branchement qui exécute du code si une condition spécifiée est true et ne l'exécute pas si la condition est false. L'instruction if a la même syntaxe qu'en JavaScript et utilise la sécurité des types de TypeScript pour effectuer des branchements conditionnels.

Syntaxe de base

La syntaxe de base de l'instruction if est la suivante.

1if (condition) {
2    // Code to execute if the condition is true
3} else if (anotherCondition) {
4    // Code to execute if the first condition is false
5    // and the another condition is true
6} else {
7    // Code to execute if all conditions are false
8}

• Si condition est true, le code du bloc suivant est exécuté.
• Si condition est false et anotherCondition est true, le code du bloc suivant est exécuté.
• Si aucune des conditions n'est true, le code du bloc final else est exécuté.

Exemple 1 : Instruction de base if-else

Dans l'exemple suivant, il vérifie si la variable x est égale ou supérieure à 10 et affiche le résultat.

1let x: number = 15;
2
3if (x >= 10) {
4    console.log("x is 10 or greater");
5} else {
6    console.log("x is less than 10");
7}
8// Outputs: x is 10 or greater

Exemple 2 : Instruction if-else if-else

Pour vérifier plusieurs conditions, utilisez else if pour ajouter des branches.

 1let score: number = 85;
 2
 3if (score >= 90) {
 4    console.log("Excellent");
 5} else if (score >= 70) {
 6    console.log("Passed");
 7} else {
 8    console.log("Failed");
 9}
10// Outputs: Passed

Exemple 3 : Instruction if avec vérification des types

Il est également possible d'effectuer des branchements conditionnels pour des types spécifiques en utilisant la fonction de vérification des types de TypeScript. Par exemple, vérifiez le type d'une variable avec l'opérateur typeof et effectuez le traitement approprié.

 1let value: any = "Hello";
 2
 3if (typeof value === "string") {
 4    console.log("The value is a string: " + value);
 5} else if (typeof value === "number") {
 6    console.log("The value is a number: " + value);
 7} else {
 8    console.log("The value is of another type");
 9}
10// Outputs: "The value is a string: Hello"

Exemple 4 : Instructions if imbriquées

Vous pouvez également imbriquer des instructions if pour vérifier des conditions complexes.

 1let age: number = 25;
 2let isMember: boolean = true;
 3
 4if (age >= 18) {
 5    if (isMember) {
 6        console.log("You are a member and 18 years old or older");
 7    } else {
 8        console.log("You are not a member but 18 years old or older");
 9    }
10} else {
11    console.log("You are under 18 years old");
12}
13// Output
14// You are a member and 18 years old or older

Opérateur ternaire (opérateur conditionnel)

Syntaxe

1condition ? valueIfTrue : valueIfFalse

Si vous souhaitez écrire une instruction if de manière plus concise, vous pouvez utiliser l'opérateur ternaire.

Exemple

1const number: number = 7;
2const result: string = number % 2 === 0 ? "Even" : "Odd";
3console.log(result); // "Odd"

Dans ce cas, comme number est 7, Odd sera affiché.

Résumé

• L'instruction if est une structure de contrôle fondamentale pour déterminer quel traitement exécuter en fonction des conditions.
• Vous pouvez gérer plusieurs conditions en utilisant else if.
• En utilisant typeof, vous pouvez tirer parti des types de TypeScript pour des branchements conditionnels.
• La gestion de conditions complexes est possible avec des instructions if imbriquées.
• Vous pouvez également utiliser l'opérateur ternaire pour écrire des branches conditionnelles de manière concise.

En TypeScript, l'utilisation d'instructions if tout en tenant compte de la sécurité des types peut améliorer la fiabilité du code.

Les instructions switch en TypeScript

L'instruction switch en TypeScript est une structure de contrôle utilisée pour effectuer un branchement de code sur la base de plusieurs conditions. Au lieu d'utiliser des instructions if-else if pour évaluer plusieurs conditions, vous pouvez utiliser une instruction switch pour écrire de manière concise une logique de branchement basée sur des valeurs spécifiques.

Syntaxe de base

 1switch (expressionToEvaluate) {
 2    case value1:
 3        // Code to execute if the expression evaluates to value1
 4        break;
 5    case value2:
 6        // Code to execute if the expression evaluates to value2
 7        break;
 8    default:
 9        // Code to execute if none of the conditions match
10}

Dans une instruction switch, si la valeur spécifiée dans un case correspond à l'expression évaluée, le bloc case est exécuté. Attention, si un break est absent, le bloc case suivant sera exécuté consécutivement. Le bloc default est exécuté si aucune des instructions case ne correspond.

Exemple 1 : Instruction de base switch

Dans l'exemple ci-dessous, un nombre représentant un jour de la semaine (de 0 à 6) est donné, et le nom du jour correspondant est affiché en fonction de cette valeur.

 1let day: number = 3;
 2
 3switch (day) {
 4    case 0:
 5        console.log("Sunday");
 6        break;
 7    case 1:
 8        console.log("Monday");
 9        break;
10    case 2:
11        console.log("Tuesday");
12        break;
13    case 3:
14        console.log("Wednesday");
15        break;
16    case 4:
17        console.log("Thursday");
18        break;
19    case 5:
20        console.log("Friday");
21        break;
22    case 6:
23        console.log("Saturday");
24        break;
25    default:
26        console.log("Invalid day");
27}
28// Outputs: Wednesday

Exemple 2 : Exemple avec default

default est utile car il s'exécute lorsque aucune des instructions case ne correspond, vous permettant ainsi de gérer des valeurs inattendues.

 1let statusText: string = "pending";
 2
 3switch (statusText) {
 4    case "success":
 5        console.log("Operation succeeded");
 6        break;
 7    case "error":
 8        console.log("An error occurred");
 9        break;
10    case "pending":
11        console.log("Processing");
12        break;
13    default:
14        console.log("Unknown status");
15}
16// Outputs: Processing

Exemple 3 : Exécuter le même processus pour plusieurs cases

Si vous souhaitez effectuer la même action pour plusieurs instructions case, vous pouvez les lister consécutivement.

 1let fruit: string = "apple";
 2
 3switch (fruit) {
 4    case "apple":
 5    case "banana":
 6    case "orange":
 7        console.log("This is a fruit");
 8        break;
 9    default:
10        console.log("This is not a fruit");
11}
12// Outputs: This is a fruit

Exemple 4 : Comportement lorsque break est omis

Omettre un break entraîne un comportement de "fall-through" où l'instruction case suivante est également exécutée.

 1let rank: number = 1;
 2
 3switch (rank) {
 4    case 1:
 5        console.log("Gold");
 6    case 2:
 7        console.log("Silver");
 8    case 3:
 9        console.log("Bronze");
10    default:
11        console.log("Not ranked");
12}
13// Outputs:
14// Gold
15// Silver
16// Bronze
17// Not ranked

De cette manière, après qu'une case correspond, l'instruction case suivante est également exécutée, c'est pourquoi un break est généralement utilisé pour éviter un "fall-through" inutile.

Résumé

• L'instruction switch est une structure de contrôle qui vous permet d'écrire une logique de branchement basée sur plusieurs conditions de manière concise.
• Chaque case doit explicitement terminer le processus en utilisant break.
• Le bloc default est exécuté si aucune des cases ne correspond.
• Il est également possible d'effectuer la même opération pour plusieurs cases.

L'instruction switch en TypeScript est utile pour gérer efficacement plusieurs conditions tout en maintenant la lisibilité du code.

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