Caché en JavaScript: Redis, Memcached y soluciones integradas para Node.js

Almacenamiento en caché en JavaScript: Redis, Memcached y soluciones integradas

El almacenamiento en caché es una de las estrategias clave para optimizar el rendimiento de las aplicaciones web. En el ecosistema de JavaScript (especialmente en Node.js), los desarrolladores tienen acceso a herramientas potentes: desde mecanismos integrados hasta sistemas distribuidos como Redis y Memcached. En este artículo, analizaremos cómo y cuándo usar cada enfoque, con ejemplos de código reales.

¿Por qué es necesario el almacenamiento en caché en Node.js?

Sin almacenamiento en caché, cada solicitud al servidor puede generar operaciones costosas: lectura de la base de datos, cálculos complejos o llamadas a APIs externas. La caché guarda el resultado de la primera solicitud y lo entrega en solicitudes posteriores. Esto reduce la carga en el servidor, disminuye el tiempo de respuesta y mejora la experiencia del usuario.

Escenarios principales de uso de caché en Node.js:

• Resultados de consultas a la base de datos (especialmente agregaciones)
• Respuestas de APIs externas (clima, tipos de cambio)
• Cálculos pesados (generación de informes, procesamiento de imágenes)
• Sesiones de usuario y tokens de autenticación

Almacenamiento en caché integrado en JavaScript (Node.js)

La forma más sencilla es usar un objeto Map u Object para almacenar datos en la memoria del proceso. Esto es rápido, pero tiene limitaciones: los datos solo existen mientras el servidor está en ejecución y la memoria no es ilimitada.

Ejemplo: Caché con Map y TTL (Time To Live)

class SimpleCache {    constructor(ttl = 60000) {        this.cache = new Map();        this.ttl = ttl; // tiempo de vida en ms (por defecto 1 minuto)    }

    set(key, value) {        this.cache.set(key, {            value,            timestamp: Date.now()        });    }

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

    delete(key) {        this.cache.delete(key);    }

    clear() {        this.cache.clear();    }}

// Usoconst cache = new SimpleCache(30000); // 30 segundoscache.set('user_123', { name: 'Iván', role: 'admin' });const user = cache.get('user_123');console.log(user); // { name: 'Iván', role: 'admin' }

Ventajas: latencia cero, simplicidad, no requiere dependencias externas.
Desventajas: los datos se pierden al reiniciar, limitados por la memoria de un solo proceso, no apto para sistemas distribuidos.

Para una caché integrada más avanzada, se puede usar el paquete node-cache, que agrega limpieza automática, estadísticas y soporte para claves de cadena.

Redis: caché distribuido para Node.js

Redis es un almacén de datos en memoria que se utiliza a menudo como caché. En Node.js, se usa el paquete ioredis (más moderno que redis) para trabajar con Redis.

Instalación y conexión básica

npm install ioredis

const Redis = require('ioredis');const redis = new Redis({    host: 'localhost',    port: 6379,    // password: 'your-password' // si es necesario});

redis.on('connect', () => console.log('Conectado a Redis'));redis.on('error', (err) => console.error('Error de Redis:', err));

Ejemplo: Almacenamiento en caché de datos con TTL

const Redis = require('ioredis');const redis = new Redis();

async function getCachedData(key, fetchFunction, ttl = 3600) {    // Intentamos obtener de la caché    const cached = await redis.get(key);    if (cached) {        return JSON.parse(cached);    }

    // Si no está, obtenemos los datos y los guardamos    const data = await fetchFunction();    await redis.setex(key, ttl, JSON.stringify(data));    return data;}

// Ejemplo de uso: almacenamiento en caché
```