Angular

Appearance

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 ​

typescript
function identite<T>(arg: T): T {
    return arg;
}
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 :

typescript
let sortieString = identite<string>("maChaine");
let sortieNumber = identite<number>(100);
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.

typescript
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"}};
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.

typescript
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);
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.

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

let objAvecId = {id: 2, nom: "Objet"};
let id = prop(objAvecId); // Fonctionne
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.