Mise en cache en JavaScript : Redis, Memcached et solutions intégrées

Formateur Python en ligne pour débutants

Apprenez Python facilement sans surcharge théorique. Résolvez des tâches pratiques avec vérification automatique et écrivez du code directement dans le navigateur.

Start Course

Mise en cache en JavaScript : Redis, Memcached et solutions intégrées : de A à Z

Dans le développement web moderne avec Node.js, les performances de l'application dépendent directement de la vitesse d'accès aux données. Chaque requête vers une base de données, une API externe ou un système de fichiers crée un délai qui s'accumule lorsque la charge augmente. La mise en cache est une stratégie de stockage temporaire des données fréquemment demandées dans un stockage rapide, permettant de réduire le temps de réponse de 10 à 100 fois. Dans cet article, nous analyserons trois approches de mise en cache en JavaScript : les solutions intégrées (Map, WeakMap, module node-cache), les systèmes distribués Redis et Memcached, ainsi que leurs combinaisons.

Pourquoi la mise en cache est-elle nécessaire dans Node.js ?

L'objectif principal de la mise en cache est de réduire la charge sur les ressources lentes (bases de données, disques, services externes) et d'accélérer la livraison des données à l'utilisateur. Dans une application web typique avec Node.js, le cache peut stocker :

Les résultats de requêtes complexes à la base de données (agrégations, JOIN).
Les réponses des API externes (météo, taux de change, données géographiques).
Les sessions utilisateur et les jetons d'authentification.
Des fragments HTML ou des pages entières (mise en cache SSR).
Les fichiers de configuration et les modèles.

Sans mise en cache, chaque accès répété aux mêmes données entraîne une duplication du travail. Avec le cache, les données sont extraites de la mémoire vive en microsecondes.

Solutions intégrées pour la mise en cache en JavaScript

Pour des scénarios simples ou des applications monothread, vous pouvez utiliser les structures de données natives de JavaScript. Elles ne nécessitent pas l'installation de paquets externes, mais ont des limitations en termes de volume et de durée de vie.

1. Map et WeakMap

L'objet Map est une collection clé-valeur, idéale pour un cache au sein d'un même processus. Exemple d'un cache simple avec TTL (time-to-live) :

class SimpleCache {  constructor(ttl = 60000) {    this.cache = new Map();    this.ttl = ttl;  }

  set(key, value) {    this.cache.set(key, {      value,      expiry: Date.now() + this.ttl    });  }

  get(key) {    const item = this.cache.get(key);    if (!item) return null;    if (Date.now() > item.expiry) {      this.cache.delete(key);      return null;    }    return item.value;  }

  has(key) {    return this.get(key) !== null;  }}

// Utilisationconst cache = new SimpleCache(5000); // TTL 5 secondescache.set('user:123', { name: 'Ivan' });console.log(cache.get('user:123')); // { name: 'Ivan' }

WeakMap se distingue par le fait que ses clés sont uniquement des objets, et le ramasse-miettes peut supprimer les entrées si aucune autre référence à l'objet-clé n'existe. C'est pratique pour mettre en cache des éléments DOM ou des objets temporaires.

2. Module node-cache

Pour un environnement de production, il est préférable d'utiliser la bibliothèque prête à l'emploi node-cache. Elle prend en charge le TTL, le nettoyage automatique et fonctionne plus rapidement qu'une solution maison :

const NodeCache = require('node-cache');const myCache = new NodeCache({ stdTTL: 100, checkperiod: 120 });

// ÉcrituremyCache.set('key', { data: 'value' });

// Lectureconst value = myCache.get('key');if (value === undefined) {  // Échec du cache — il faut récupérer les données depuis la base de données}

// SuppressionmyCache.del('key');

Les solutions intégrées conviennent aux applications monolithiques ou aux microservices avec une seule instance. Cependant, lors de la mise à l'échelle sur plusieurs processus ou serveurs, les données deviennent incohérentes — c'est là que les caches distribués sont nécessaires.

Redis : puissant magasin de données en mémoire

Redis est un magasin de données en mémoire hautes performances, prenant en charge les chaînes, les hachages, les listes, les ensembles et d'autres structures. Pour Node.js, on utilise le paquet redis ou ioredis. Redis est idéal pour la mise en cache grâce à :