Les génériques

Les types génériques en TypeScript offrent un moyen de créer des composants qui peuvent travailler avec une variété de types plutôt qu'un seul. Cela ajoute une couche de flexibilité et de réutilisabilité à vos fonctions, classes, interfaces, et autres structures, tout en conservant les avantages du typage fort.

Concept de Type Générique

Un type générique est un type qui est lié à un autre type spécifié au moment de l'utilisation. Cela permet aux composants de traiter différents types sans perdre l'information de type.

Exemple de Fonction Générique

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

Dans cet exemple, T est un type générique. Lorsque vous utilisez la fonction identite, vous pouvez spécifier le type :

let sortieString = identite<string>("maChaine");
let sortieNumber = identite<number>(100);

Types Génériques avec Interfaces

Vous pouvez aussi utiliser les types génériques dans les interfaces pour définir des structures de données flexibles.

interface Reponse<T> {
    status: number;
    message: T;
}

let reponseString: Reponse<string> = {status: 200, message: "Ok"};
let reponseObjet: Reponse<{ data: string }> = {status: 200, message: {data: "Données"}};

Types Génériques avec Classes

Les classes peuvent également être génériques, ce qui est utile pour les structures de données comme les piles, les files, les arbres, etc.

class Pile<T> {
    private elements: T[] = [];

    push(element: T) {
        this.elements.push(element);
    }

    pop(): T | undefined {
        return this.elements.pop();
    }
}

let pileDeNombres = new Pile<number>();
pileDeNombres.push(1);

Contraintes de Type Générique

Les types génériques peuvent être contraints à respecter certaines formes ou structures, en utilisant extends.

function prop<T extends { id: number }>(obj: T) {
    return obj.id;
}

let objAvecId = {id: 2, nom: "Objet"};
let id = prop(objAvecId); // Fonctionne

Utilisation des Types Génériques

• Flexibilité : Les types génériques permettent de créer des composants qui peuvent être utilisés avec différents types.
• Réutilisabilité : Ils augmentent la réutilisabilité du code.
• Sécurité de Type : Ils maintiennent la sécurité de type en permettant aux développeurs de spécifier des types explicites.