En réfléchissant à la manière de compliquer davantage l'instruction if, en particulier le bloc de conditions, grâce aux développeurs bienveillants de TypeScript et JavaScript, vous pouvez désormais utiliser plusieurs conditions dans un seul bloc.

Par exemple, vous devez définir deux conditions : le nombre doit être supérieur à `0` **ET** inférieur à `99`. (Par exemple, vous êtes un vendeur de sets **LEGO**)

let age: number = 80;
if (age > 0 && age < 99) {
    console.log('You can buy a LEGO');
}

Comme vous pouvez le voir, nous avons défini une double condition. Nous avons besoin que l'âge soit supérieur à `0` **ET** inférieur à `99`. Pour y parvenir, nous avons utilisé des symboles comme `&&`. Il y a une autre option, qui est lorsque nous devons définir plusieurs conditions, et que l'une d'elles peut être satisfaite. En termes plus simples - **OU**. Regardons un exemple :

let rate: string = 'Very well!'
if (rate == 'Very well!' || rate == 'Good') {
    console.log('You did a good job!');
}

Comme vous pouvez le voir, nous avons utilisé `||` pour définir la condition **OU**. Dans notre code ci-dessus, si la note est `Very well` ou `Good`, alors nous avons bien fait notre travail. 
Rappelons rapidement ces mots-clés :

1.  **ET** = `&&`;
2.  **OU** = `||`.

- `true && false` = `false`;
- `true && true` = `true`;
- `false && false` = `false`;
- `true || true` = `true`;
- `true || false` = `true`;
- `false || false` = `false`.

D'ailleurs, vous pouvez utiliser plusieurs de ces conditions simultanément. Par exemple, vous pourriez avoir besoin de **3 ou 4** d'entre elles. Par exemple, si nous devons récupérer un nombre **entre 20 et 50** `OR` **entre 70 et 100** :

let num: number = 25;
if ((num > 20 && num < 50) || (num > 70 && num < 100)) {
    console.log("I don't know what to write here, YOU WON!")
}

Nous pouvons **regrouper les conditions entre parenthèses**, tout comme en mathématiques. Cela signifie que les conditions à l'intérieur des parenthèses seront **vérifiées en premier**, puis les conditions à l'extérieur des parenthèses seront évaluées.

Quel sera le résultat de l'exécution de ce code ?

Ce cours est conçu pour les débutants absolus qui souhaitent maîtriser les bases du langage de programmation TypeScript. TypeScript est un langage moderne et puissant qui étend les capacités de JavaScript, rendant votre code plus fiable et lisible. Nous commencerons par les bases, en couvrant les variables, les types de données, les opérateurs de comparaison et les instructions conditionnelles. Ensuite, nous nous plongerons dans le travail avec les tableaux et les boucles. À la fin de ce cours, vous serez prêt à créer des programmes simples en TypeScript et à poursuivre votre apprentissage vers des sujets plus avancés.

Cette section vous introduit à TypeScript. Vous apprendrez pourquoi TypeScript est précieux et comment il diffère de JavaScript.

Nous allons prendre le contrôle du code ! Dans cette section, vous apprendrez à définir des conditions pour l'exécution du code en TypeScript. Vous découvrirez pourquoi cela est utilisé et comment l'utiliser correctement, afin que votre code devienne l'envie de tous les meilleurs programmeurs !

Familiarisons-nous avec un moyen pratique de stocker des données dans une collection d'éléments - un array. Vous apprendrez à créer et utiliser des arrays, ainsi qu'à ajouter et travailler avec des éléments dans un array. Une structure importante et fondamentale pour tout programmeur.

Automatisez les tâches avec une grande quantité de données ou de variables. Les loops vous aideront dans cette tâche, vous permettant de traiter une grande quantité de données et d'obtenir rapidement des résultats en seulement quelques lignes de code. Nous explorerons les types fondamentaux de loops et vous apprendrons à les utiliser efficacement !

Il est temps d'apprendre enfin à écrire vos propres fonctions qui effectueront les opérations que vous spécifiez. Les fonctions vous aideront à organiser votre code, à le diviser en morceaux gérables et à les appeler en une seule ligne. Il est temps d'apprendre !

Introduction à TypeScript

Conditions Complexes