Aller plus loin sur les types

TypeScript propose plusieurs types avancés qui permettent de gérer des cas de programmation plus complexes et d'assurer une plus grande rigueur dans la vérification des types. Voici quelques-uns des types avancés les plus utilisés en TypeScript :

Union Types

Un type union est utilisé pour définir une variable qui peut contenir plusieurs types différents.

let id: number | string;
id = 101; // valide
id = "202"; // valide

Intersection Types

Les types intersection sont utilisés pour combiner plusieurs types en un seul. Cela permet de mélanger plusieurs types pour en créer un nouveau qui possède toutes les propriétés de ces types.

interface Employe {
    nom: string;
}

interface Manager {
    equipe: number;
}

type ChefEquipe = Employe & Manager;
let chef: ChefEquipe = { nom: "Alice", equipe: 4 };

Type Guards

Les Type Guards permettent de vérifier le type d'une variable au sein d'un bloc de code.

function estChaine(texte: string | number): texte is string {
    return typeof texte === "string";
}

if (estChaine(id)) {
    console.log(id.toUpperCase());
} else {
    console.log(id);
}

Type Assertions

Les assertions de type sont utilisées pour indiquer explicitement au compilateur le type d'une variable. Elles n'altèrent pas le comportement du code au moment de l'exécution, mais fournissent des informations au compilateur.

let maVariable: any = "Ceci est une chaîne de caractères";
let longueur: number = (maVariable as string).length;

Enums avec Types Discriminés (Discriminated Unions)

Il s'agit d'une technique pour travailler avec des unions de types où chaque type a un champ commun, qui est utilisé pour discriminer entre les autres types.

interface Carre {
    type: "carre";
    cote: number;
}

interface Cercle {
    type: "cercle";
    rayon: number;
}

type Forme = Carre | Cercle;

function aire(forme: Forme) {
    if (forme.type === "carre") {
        return forme.cote * forme.cote;
    } else {
        return forme.rayon * Math.PI * 2;
    }
}

Generic Types

Les types génériques permettent de créer des composants qui peuvent travailler avec plusieurs types plutôt qu'un seul. Cela ajoute une couche de flexibilité et de réutilisabilité.

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

let sortie = identite<string>("monTexte");

Mapped Types

Les types mappés permettent de créer des types basés sur un autre type en transformant chaque propriété. Ils sont souvent utilisés pour rendre toutes les propriétés d'un type optionnelles ou en lecture seule.

type Optionnel<T> = {
    [P in keyof T]?: T[P];
};

type EmployeOptionnel = Optionnel<Employe>;