Generics en JavaScript : pourquoi en avons-nous besoin et comment les utiliser en pratique

Introduction : pourquoi JavaScript a-t-il besoin des Generics ?

Le développement en JavaScript (notamment dans l'environnement Node.js) est souvent confronté au problème de duplication de code. Imaginez que vous deviez écrire une fonction qui fonctionne à la fois avec des nombres, des chaînes de caractères et des tableaux. Sans Generics, vous écrivez soit plusieurs surcharges, soit vous utilisez any, perdant ainsi toute la magie des types.

Generics est un mécanisme qui permet de créer des composants (fonctions, classes, interfaces) qui fonctionnent avec différents types de données tout en conservant un typage strict. Dans le contexte de JavaScript, les generics sont pleinement accessibles via TypeScript, mais comprendre leurs principes est essentiel pour tout développeur moderne.

Dans cet article, nous verrons pourquoi les generics sont nécessaires, comment les utiliser en pratique dans Node.js et pourquoi ils rendent votre code plus sûr et plus réutilisable.

1. Generics en TypeScript : la base de la sécurité des types

Bien que le JavaScript pur n'ait pas de support natif pour les generics, TypeScript (une surcouche de JS) les fournit pleinement. C'est pourquoi tous les frameworks et bibliothèques modernes pour Node.js (NestJS, Express avec types) les utilisent activement.

Exemple simple : la fonction identity

L'exemple classique est une fonction qui retourne ce qu'elle reçoit :

// Sans generics — on utilise any (on perd le type)function identity(arg: any): any {  return arg;}

// Avec generic — le type est conservéfunction identity<T>(arg: T): T {  return arg;}

// Utilisationconst num = identity<number>(42);  // Type : numberconst str = identity<string>('hello'); // Type : string

Remarquez : <T> est un paramètre de type. Nous disons à TypeScript : « Le type sera fourni plus tard ». Le compilateur déduit automatiquement le type, donc on peut souvent écrire simplement identity(42).

Pourquoi est-ce important pour Node.js ?

Dans Node.js, vous travaillez constamment avec des API, des bases de données et des services externes. Les Generics permettent de garantir que les données arrivent exactement dans le format attendu :

// Fonction pour travailler avec une APIasync function fetchData<T>(url: string): Promise<T> {  const response = await fetch(url);  return response.json() as Promise<T>;}

// Maintenant, nous connaissons la structure exacte de la réponseinterface User {  id: number;  name: string;}

const user = await fetchData<User>('/api/user/1');// user.name — chaîne, user.id — nombre (TypeScript le vérifie)

2. Scénarios pratiques : travailler avec des tableaux et des collections

Les Generics sont particulièrement utiles pour travailler avec des tableaux et des collections de données. Prenons un exemple concret de Node.js — une fonction de filtrage et de transformation.

Fonction générique pour le mapping

// Fonction qui transforme un tableau d'un type en un tableau d'un autre typefunction mapArray<T, U>(items: T[], mapper: (item: T) => U): U[] {  return items.map(mapper);}

// Exemple : à partir de User, on obtient uniquement les nomsinterface User {  id: number;  name: string;  email: string;}

const users: User[] = [  { id: 1, name: 'Alice', email: 'alice@example.com' },  { id: 2, name: 'Bob', email: 'bob@example.com' }];

const names: string[] = mapArray(users, (user) => user.name);// names : ['Alice', 'Bob'] — le type string[] est garanti

Ici, <T, U> sont deux paramètres de type. T est le type du tableau d'entrée, U est le type du résultat. Cela offre une flexibilité maximale sans perte de types.

Classe générique pour une pile

Dans Node.js, les structures de données sont souvent nécessaires. Créons une pile typée :

class Stack<T> {  private items: T[] = [];

  pu