Les types

TypeScript est un langage fortement typé qui étend JavaScript en ajoutant des types. Cela permet aux développeurs de définir explicitement la nature des valeurs que les variables peuvent contenir, offrant ainsi une vérification des types au moment de la compilation et prévenant de nombreux types d'erreurs courants en JavaScript. Voici un aperçu des types de base en TypeScript et de leur utilisation :

Types Primitifs

1. Boolean :

   • Représente une valeur vraie/fausse.

   let estValide: boolean = true;

2. Number :

   • Comme en JavaScript, tous les nombres en TypeScript, qu'ils soient entiers ou à virgule flottante, sont de type number.

   let age: number = 25;

3. String :

   • Pour les textes et les chaînes de caractères.

   let nom: string = "Alice";

4. Array :

   • Deux syntaxes pour définir des tableaux, avec le type des éléments.

   let nombres: number[] = [1, 2, 3];
   let nombres2: Array<number> = [1, 2, 3];

Types Spéciaux

1. Any :

   • Pour les valeurs dont le type n'est pas connu au moment de l'écriture du script. À utiliser avec prudence.

   let pasSur: any = 4; // Peut être de n'importe quel type

2. Void :

   • L'opposé de any, pour les fonctions qui ne retournent rien.

   function afficherMessage(): void {
       console.log("Hello!");
   }

3. Null et Undefined :

   • Semblable à leurs homologues en JavaScript, mais avec une utilisation plus stricte en mode strict.

   let u: undefined = undefined;
   let n: null = null;

4. Tuple :

   • Un tableau avec un nombre fixe d'éléments dont les types sont connus, mais pas nécessairement les mêmes.

   let x: [string, number] = ["hello", 10];

5. Enum :

   • Un moyen de donner des noms plus conviviaux à un ensemble de valeurs numériques.

   enum Couleur {Rouge, Vert, Bleu}
   let c: Couleur = Couleur.Vert;

6. Unknown :

   • Semblable à any, mais plus sûr car il nécessite une vérification de type pour être manipulé.

   let valeurInconnue: unknown = 4;

Types Avancés

1. Union Types :

   • Permet à une variable d'être de plusieurs types.

   let multiple: number | string;
   multiple = 20; // Valide
   multiple = "Vingt"; // Valide

2. Literal Types :

   • Permet de définir des types avec des valeurs exactes.

   let texteExact: "Bonjour";
   texteExact = "Bonjour"; // Valide

3. Type Assertions :

   • Manière de dire à TypeScript que vous connaissez le type d'une valeur mieux que TypeScript.

   let maChaine: any = "Ceci est une chaîne";
   let longueurDeChaine: number = (maChaine as string).length;

Types Génériques

• Utilisés pour créer des composants réutilisables.

function identite<T>(arg: T): T {
    return arg;
}