Gestion des paramètres de requête (query parameters, route parameters)

Rendre vos routes dynamiques : les parametres

Les routes que nous avons définies jusqu'à présent étaient statiques (ex: `/`, `/about`, `/api/users`). Cependant, la plupart des applications web et API nécessitent de gérer des routes dynamiques, où certaines parties de l'URL ou des informations supplémentaires dans l'URL peuvent varier. Par exemple, vous pourriez vouloir récupérer un utilisateur spécifique par son ID (`/users/123`), afficher des produits d'une catégorie donnée (`/products/electronics`), ou filtrer une liste de résultats de recherche (`/search?term=node&page=2`).

Express.js excelle dans la gestion de ces informations dynamiques grâce à deux mécanismes principaux : les paramètres de route (route parameters) et les paramètres de requête (query parameters). Express parse automatiquement ces paramètres à partir de l'URL entrante et les rend facilement accessibles dans l'objet `request` (`req`) de vos gestionnaires de routes.

Comprendre comment définir et utiliser ces deux types de paramètres est essentiel pour créer des API RESTful et des applications web interactives et flexibles.

Parametres de requete (`req.query`) : filtrage, tri et options

Les paramètres de requête (query parameters ou query string) sont des paires clé-valeur ajoutées à la fin de l'URL après un point d'interrogation (`?`), séparées par des esperluettes (`&`). Ils sont généralement utilisés pour fournir des options supplémentaires, filtrer des collections de ressources, gérer la pagination, ou spécifier des critères de tri.

Par exemple, dans l'URL `GET /api/articles?category=tech&limit=10&sort=date`, les paramètres de requête sont :

• `category` avec la valeur `'tech'`
• `limit` avec la valeur `'10'`
• `sort` avec la valeur `'date'`

Express parse automatiquement cette partie de l'URL et la rend disponible sous forme d'un objet JavaScript dans `req.query`. Dans l'exemple ci-dessus, `req.query` serait équivalent à :

{
  category: 'tech',
  limit: '10',
  sort: 'date'
}

Important : Toutes les valeurs dans `req.query` sont initialement des chaînes de caractères. Si vous attendez un nombre (comme pour `limit`), vous devrez le convertir explicitement (par exemple avec `parseInt()`).

Voici comment accéder à `req.query` dans un gestionnaire de route :

const express = require('express');
const app = express();

app.get('/api/articles', (req, res) => {
  // Accéder aux paramètres de requête via req.query
  const category = req.query.category;
  const limit = parseInt(req.query.limit, 10) || 10; // Convertir en nombre, valeur par défaut 10
  const sortBy = req.query.sort || 'title'; // Valeur par défaut 'title'

  console.log(`Filtrage demandé : Catégorie=${category}, Limite=${limit}, Tri=${sortBy}`);

  // Ici, vous utiliseriez ces paramètres pour interroger votre base de données
  // Par exemple: db.findArticles({ category: category }).limit(limit).sort(sortBy)...

  res.json({ 
    message: 'Liste des articles (filtrée/triée potentiellement)',
    filters: req.query // Renvoyer les filtres reçus pour confirmation
  });
});

app.listen(3000, () => console.log('Serveur démarré...'));
// Pour tester: http://localhost:3000/api/articles?category=javascript&limit=5&sort=popularity

Parametres de route (`req.params`) : identifier des ressources specifiques

Les paramètres de route sont des segments nommés de l'URL elle-même, utilisés pour capturer des valeurs directement depuis le chemin. Ils sont définis dans la chaîne de chemin de la route en utilisant un préfixe deux-points (`:`), suivi du nom du paramètre.

Ils sont idéaux pour identifier une ressource spécifique. Par exemple :

• `/users/:userId` : Capture l'ID de l'utilisateur.
• `/products/:category/:productId` : Capture la catégorie et l'ID du produit.
• `/files/*` ou `/files/:filePath(*)` : Capture tout ce qui suit `/files/`.

Lorsqu'une requête entrante correspond à une route contenant de tels paramètres, Express extrait les valeurs correspondantes de l'URL et les rend disponibles sous forme d'un objet JavaScript dans `req.params`. Les clés de cet objet sont les noms des paramètres définis dans la route (sans le `:`).

Par exemple, si vous définissez la route `app.get('/users/:userId/books/:bookId', ...)`, et qu'une requête arrive pour `/users/123/books/456`, alors `req.params` sera :

{
  userId: '123',
  bookId: '456'
}

Important : Comme pour `req.query`, les valeurs dans `req.params` sont également des chaînes de caractères par défaut et peuvent nécessiter une conversion.

Voici comment définir et utiliser les paramètres de route :

const express = require('express');
const app = express();

// Route avec un paramètre :userId
app.get('/users/:userId', (req, res) => {
  // Accéder au paramètre via req.params
  const userId = req.params.userId;
  console.log(`Demande d'information pour l'utilisateur ID: ${userId}`);

  // Ici, vous utiliseriez userId pour chercher l'utilisateur dans la BDD
  // Par exemple: db.findUserById(userId)...

  // Convertir en nombre si nécessaire pour la logique métier
  const userIdNum = parseInt(userId, 10);
  if (isNaN(userIdNum)) {
      return res.status(400).send('User ID doit être un nombre.');
  }

  res.json({ id: userIdNum, name: `Utilisateur ${userIdNum}` }); // Exemple de réponse
});

// Route avec plusieurs paramètres
app.get('/articles/:category/:articleSlug', (req, res) => {
  const category = req.params.category;
  const slug = req.params.articleSlug;

  console.log(`Demande pour l'article '${slug}' dans la catégorie '${category}'`);
  res.send(`Affichage de l'article ${slug} de la catégorie ${category}`);
});

app.listen(3000, () => console.log('Serveur démarré...'));
// Pour tester: http://localhost:3000/users/42
// Pour tester: http://localhost:3000/articles/technologie/mon-super-article

Bonnes pratiques et considerations

Validation et Sécurité : C'est le point le plus important. Les valeurs provenant de `req.query` et `req.params` sont des entrées utilisateur et ne doivent jamais être utilisées directement sans validation et/ou nettoyage (sanitization). Validez que les ID sont des nombres, que les chaînes ont une longueur raisonnable, que les valeurs correspondent à des options attendues, etc. Utilisez des bibliothèques comme `express-validator` pour simplifier ce processus. L'absence de validation peut entraîner des erreurs, des comportements inattendus, et surtout des failles de sécurité (injection SQL, Cross-Site Scripting - XSS).

Conversion de Type : N'oubliez pas que les valeurs sont des chaînes. Convertissez-les explicitement en nombres (`parseInt`, `parseFloat`), booléens, ou dates si nécessaire, en gérant les cas où la conversion échoue (par exemple, `parseInt` renvoyant `NaN`).

Différence sémantique : Utilisez `req.params` pour identifier des ressources spécifiques faisant partie intégrante du chemin de la ressource (ex: ID unique). Utilisez `req.query` pour les options facultatives comme le filtrage, le tri, la pagination, ou la sélection de champs.

En maîtrisant l'accès et l'utilisation de `req.query` et `req.params`, vous pouvez créer des routes Express.js dynamiques et puissantes, capables de répondre de manière flexible aux besoins variés des clients de votre application ou API.