Angular

Appearance

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.
    typescript
    let estValide: boolean = true;
    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.
    typescript
    let age: number = 25;
    let age: number = 25;

  3. String :

    • Pour les textes et les chaînes de caractères.
    typescript
    let nom: string = "Alice";
    let nom: string = "Alice";

  4. Array :

    • Deux syntaxes pour définir des tableaux, avec le type des éléments.
    typescript
    let nombres: number[] = [1, 2, 3];
let nombres2: Array<number> = [1, 2, 3];
    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.
    typescript
    let pasSur: any = 4; // Peut être de n'importe quel type
    let pasSur: any = 4; // Peut être de n'importe quel type

  2. Void :

    • L'opposé de any, pour les fonctions qui ne retournent rien.
    typescript
    function afficherMessage(): void {
    console.log("Hello!");
}
    function afficherMessage(): void {
    console.log("Hello!");
}

  3. Null et Undefined :

    • Semblable à leurs homologues en JavaScript, mais avec une utilisation plus stricte en mode strict.
    typescript
    let u: undefined = undefined;
let n: null = null;
    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.
    typescript
    let x: [string, number] = ["hello", 10];
    let x: [string, number] = ["hello", 10];

  5. Enum :

    • Un moyen de donner des noms plus conviviaux à un ensemble de valeurs numériques.
    typescript
    enum Couleur {Rouge, Vert, Bleu}
let c: Couleur = Couleur.Vert;
    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é.
    typescript
    let valeurInconnue: unknown = 4;
    let valeurInconnue: unknown = 4;

Types Avancés ​

  1. Union Types :

    • Permet à une variable d'être de plusieurs types.
    typescript
    let multiple: number | string;
multiple = 20; // Valide
multiple = "Vingt"; // Valide
    let multiple: number | string;
multiple = 20; // Valide
multiple = "Vingt"; // Valide

  2. Literal Types :

    • Permet de définir des types avec des valeurs exactes.
    typescript
    let texteExact: "Bonjour";
texteExact = "Bonjour"; // Valide
    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.
    typescript
    let maChaine: any = "Ceci est une chaîne";
let longueurDeChaine: number = (maChaine as string).length;
    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.
typescript
function identite<T>(arg: T): T {
    return arg;
}
function identite<T>(arg: T): T {
    return arg;
}