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

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

La mise en cache est l'un des outils clés pour améliorer les performances des applications web et des services. Dans l'écosystème TypeScript et Node.js, les développeurs peuvent choisir entre des systèmes externes puissants (Redis, Memcached) et des solutions intégrées légères. Dans cet article, nous analyserons les trois approches, fournirons des exemples pratiques de code en TypeScript et vous aiderons à choisir la stratégie optimale pour votre projet.

Pourquoi la mise en cache en TypeScript est-elle nécessaire ?

La mise en cache permet de réduire le temps de réponse du serveur, de diminuer la charge sur les bases de données et les API externes, ainsi que de réduire les latences lors de requêtes répétées. En TypeScript, fonctionnant sur Node.js, le cache est particulièrement utile pour :

\n
• stocker les résultats de calculs coûteux ;
\n
• mettre en cache les réponses des API externes ;
\n
• conserver les sessions utilisateur ;
\n
• réduire le nombre de requêtes vers la base de données.
\n

1. Solutions intégrées pour la mise en cache en TypeScript

Pour les petits projets ou les prototypes, vous pouvez utiliser les outils intégrés de Node.js sans installer de paquets supplémentaires.

1.1. Utilisation de Map

La méthode la plus simple est d'utiliser un objet Map ou un objet simple. Cependant, un tel cache ne vit que dans la mémoire d'un seul processus et est perdu lors du redémarrage.

// Cache simple basé sur Map\nclass SimpleCache<T> {\n    private cache = new Map<string, T>();\n\n    get(key: string): T | undefined {\n        return this.cache.get(key);\n    }\n\n    set(key: string, value: T): void {\n        this.cache.set(key, value);\n    }\n\n    clear(): void {\n        this.cache.clear();\n    }\n}\n\n// Exemple d'utilisation\nconst cache = new SimpleCache<string>();\ncache.set('user:1', 'Alice');\nconsole.log(cache.get('user:1')); // Alice

1.2. Cache avec TTL (Time-To-Live)

Une version plus avancée est un cache avec suppression automatique des entrées après un temps défini.

// Cache avec TTL\nclass TtlCache<T> {\n    private cache = new Map<string, { value: T; expiry: number }>();\n\n    get(key: string): T | undefined {\n        const item = this.cache.get(key);\n        if (!item) return undefined;\n        if (Date.now() > item.expiry) {\n            this.cache.delete(key);\n            return undefined;\n        }\n        return item.value;\n    }\n\n    set(key: string, value: T, ttlMs: number): void {\n        this.cache.set(key, {\n            value,\n            expiry: Date.now() + ttlMs,\n        });\n    }\n}\n\n// Exemple\nconst ttlCache = new TtlCache<number>();\nttlCache.set('price', 100, 5000); // vit 5 secondes\nsetTimeout(() => console.log(ttlCache.get('price')), 6000); // undefined

2. Mise en cache avec Redis en TypeScript

Redis est un système de stockage de données in-memory populaire qui prend en charge des structures de données avancées, pub/sub et la persistance. Pour TypeScript, on utilise le paquet ioredis.

2.1. Installation et connexion

npm install ioredis\nnpm install @types/ioredis --save-dev

import Redis from 'ioredis';\n\nconst redis = new Redis({\n    host: 'localhost',\n    port: 6379,\n});\n\nredis.on('connect', () => console.log('Connecté à Redis'));\nredis.on('error', (err) => console.error('Erreur Redis', err));

2.2. Opérations de base set/get

// Sauvegarder une valeur\nawait redis.set('user:1:name', 'Alice');\n\n// Récupérer une valeur\nconst name = await redis.get('user:1:name');\nconsole.log(name); // Alice\n\n// Définir un TTL (en secondes)\nawait redis.setex('session:123', 3600, 'active');

2.3. Travailler avec des objets (JSON)

// Sauvegarder un objet\nconst user = { id: 1, name: 'Alice', email: 'alice@example.com' };\nawait redis.set('user:1', JSON.stringify(user));\n\n// Lire et parser\nconst r