Cache em JavaScript: Redis, Memcached e soluções integradas para Node.js

Cache em JavaScript: Redis, Memcached e soluções integradas

Cache é uma das principais estratégias de otimização de desempenho para aplicações web. No ecossistema JavaScript (especialmente Node.js), os desenvolvedores têm acesso a ferramentas poderosas: desde mecanismos integrados até sistemas distribuídos como Redis e Memcached. Neste artigo, vamos analisar como e quando usar cada abordagem, com exemplos reais de código.

Por que o cache é necessário no Node.js?

Sem cache, cada requisição ao servidor pode levar a operações custosas: leitura do banco de dados, cálculos complexos ou chamadas a APIs externas. O cache armazena o resultado da primeira requisição e o entrega em requisições subsequentes. Isso reduz a carga no servidor, diminui o tempo de resposta e melhora a experiência do usuário.

Principais cenários de uso de cache no Node.js:

• Resultados de consultas ao banco de dados (especialmente agregações)
• Respostas de APIs externas (clima, taxas de câmbio)
• Cálculos pesados (geração de relatórios, processamento de imagens)
• Sessões de usuários e tokens de autenticação

Cache integrado em JavaScript (Node.js)

A maneira mais simples é usar um objeto Map ou Object para armazenar dados na memória do processo. É rápido, mas tem limitações: os dados só existem enquanto o servidor está em execução e a memória não é ilimitada.

Exemplo: Cache com Map e TTL (Time To Live)

class SimpleCache {    constructor(ttl = 60000) {        this.cache = new Map();        this.ttl = ttl; // tempo de vida em ms (padrão 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: 'Ivan', role: 'admin' });const user = cache.get('user_123');console.log(user); // { name: 'Ivan', role: 'admin' }

Vantagens: latência zero, simplicidade, não requer dependências externas.
Desvantagens: dados são perdidos na reinicialização, limitados pela memória de um único processo, não adequado para sistemas distribuídos.

Para um cache integrado mais avançado, você pode usar o pacote node-cache, que adiciona limpeza automática, estatísticas e suporte para chaves string.

Redis: cache distribuído para Node.js

Redis é um armazenamento de dados in-memory frequentemente usado como cache. No Node.js, o pacote ioredis (mais moderno que o redis) é usado para trabalhar com Redis.

Instalação e conexão básica

npm install ioredis

const Redis = require('ioredis');const redis = new Redis({    host: 'localhost',    port: 6379,    // password: 'your-password' // se necessário});

redis.on('connect', () => console.log('Conectado ao Redis'));redis.on('error', (err) => console.error('Erro no Redis:', err));

Exemplo: Cache de dados com TTL

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

async function getCachedData(key, fetchFunction, ttl = 3600) {    // Tenta obter do cache    const cached = await redis.get(key);    if (cached) {        return JSON.parse(cached);    }

    // Se não existe — obtém os dados e armazena    const data = await fetchFunction();    await redis.setex(key, ttl, JSON.stringify(data));    return data;}

// Exemplo de uso: cache de
```