Génériques

Bienvenue dans la prochaine leçon ! Vous allez découvrir les génériques, une fonctionnalité puissante de TypeScript qui vous permet de créer des composants réutilisables et sûrs en matière de typage. Commençons !

Que sont les génériques ?

Les génériques vous permettent d’écrire du code réutilisable qui fonctionne avec n’importe quel type. Ils servent d’emplacements réservés pour les types que vous pouvez préciser lorsque vous les utilisez.

Exemple : une fonction générique :

Tâche : Écrivez une fonction générique qui accepte un argument et le renvoie sans le modifier.

function identity<T>(value: T): T {
  return value;
}

console.log(identity<string>("Hello")); 
// Output: Hello
console.log(identity<number>(42)); 
// Output: 42

Pourquoi utiliser les génériques ?

Les génériques vous aident à :

• Écrire du code réutilisable : les fonctions et les classes peuvent fonctionner avec différents types.
• Garantir la sécurité du typage : vous pouvez imposer des types précis sans sacrifier la flexibilité.
• Réduire la redondance : évitez d’écrire plusieurs versions d’une même fonction ou classe pour différents types.

Conseil : Utilisez les génériques pour écrire un code plus flexible et plus facile à maintenir.

Fonctions génériques

Vous pouvez utiliser les génériques pour créer des fonctions flexibles. Exemple :

Tâche : Écrivez une fonction générique qui fusionne deux objets et renvoie le résultat.

function merge<T, U>(obj1: T, obj2: U): T & U {
  return { ...obj1, ...obj2 };
}

let merged = merge({ name: "Alice" }, { age: 25 });
console.log(merged); 
// Output: { name: "Alice", age: 25 }

Classes génériques

Les génériques peuvent être utilisés dans les classes afin de les rendre réutilisables avec différents types. Exemple :

class Box<T> {
  private contents: T;

  constructor(contents: T) {
    this.contents = contents;
  }

  getContents(): T {
    return this.contents;
  }
}

let stringBox = new Box<string>("Hello");
console.log(stringBox.getContents()); 
// Output: Hello

let numberBox = new Box<number>(42);
console.log(numberBox.getContents()); 
// Output: 42

Interfaces génériques

Les interfaces peuvent également utiliser des génériques pour imposer une structure à différents types. Exemple :

Tâche : Définissez une interface générique et créez un objet qui l’implémente.

interface Pair<T, U> {
  first: T;
  second: U;
}

let coordinates: Pair<number, number> = { first: 10, second: 20 };
console.log(coordinates); 
// Output: { first: 10, second: 20 }

Contraintes génériques

Vous pouvez ajouter des contraintes aux génériques pour vous assurer qu’ils ne fonctionnent qu’avec certains types. Exemple :

function printLength<T extends { length: number }>(item: T): void {
  console.log(`Length: ${item.length}`);
}

printLength("Hello"); 
// Output: Length: 5
printLength([1, 2, 3]); 
// Output: Length: 3
// printLength(42); 
// Error: Argument of type 'number' is not assignable to parameter of type '{ length: number }'.

Valeurs par défaut des génériques

Vous pouvez définir des types par défaut pour les génériques lorsqu’aucun type n’est fourni. Exemple :

Tâche : Créez une fonction générique avec un type par défaut et testez-la avec différents types.

function wrap<T = string>(value: T): T[] {
  return [value];
}

console.log(wrap("Hello")); // Output: ["Hello"]
console.log(wrap(42)); // Output: [42]

Excellent travail !

Félicitations ! Vous avez appris à utiliser les génériques dans TypeScript pour créer des fonctions, des classes et des interfaces réutilisables et sûres en matière de typage. Les génériques sont un outil puissant pour écrire un code flexible et évolutif. Dans la prochaine leçon, vous découvrirez des types avancés, tels que les types mappés et conditionnels. Continuons à coder !