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

Introdução: Por que o Caching em JavaScript é Necessário

Aplicações web modernas em Node.js processam milhões de requisições diariamente. Sem um cache adequado, cada chamada a um banco de dados ou API externa cria um atraso, aumenta a carga do servidor e degrada a experiência do usuário. O cache é uma técnica de armazenar temporariamente dados frequentemente solicitados em um armazenamento rápido, para que operações pesadas não sejam repetidas em requisições subsequentes.

No ecossistema JavaScript (Node.js), existem três principais abordagens para cache:

• Soluções nativas (Cache em memória) — bibliotecas simples que armazenam dados na memória do processo Node.js.
• Memcached — um sistema de cache distribuído que funciona em RAM.
• Redis — um armazenamento de dados em memória avançado com suporte para estruturas de dados complexas.

Neste artigo, analisaremos cada abordagem em detalhes, forneceremos exemplos de código em JavaScript e ajudaremos você a escolher a solução ideal para o seu projeto.

Soluções Nativas para Cache em Node.js

A maneira mais simples de organizar o cache é usar recursos nativos do JavaScript ou bibliotecas leves. Essas soluções não exigem a instalação de serviços externos e são ideais para projetos pequenos ou protótipos.

Cache Simples com Objeto

Um exemplo básico de cache usando um objeto JavaScript comum:

class SimpleCache {  constructor() {    this.cache = {};  }

  get(key) {    return this.cache[key];  }

  set(key, value, ttl = 60000) {    this.cache[key] = value;    setTimeout(() => {      delete this.cache[key];    }, ttl);  }

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

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

// Usageconst cache = new SimpleCache();cache.set('user:123', { name: 'Anna', role: 'admin' }, 30000);console.log(cache.get('user:123')); // { name: 'Anna', role: 'admin' }

Desvantagens desta abordagem: sem limpeza automática de memória, vazamentos de memória com um grande número de chaves, sem suporte para cache distribuído.

Biblioteca node-cache

Uma opção mais avançada é usar o pacote node-cache:

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

// Save datamyCache.set('key', { data: 'value' });

// Get dataconst value = myCache.get('key');if (value === undefined) {  // Data not found — need to fetch from DB  console.log('Cache miss');} else {  console.log('Cache hit:', value);}

// Delete by keymyCache.del('key');

// Statisticsconsole.log(myCache.getStats());

O node-cache suporta TTL (tempo de vida), limpeza automática de chaves expiradas e estatísticas básicas. No entanto, não é adequado para aplicações multiprocesso — cada processo Node.js armazena sua própria cópia dos dados.

Memcached: Cache Distribuído Leve

Memcached é um sistema de cache distribuído de alto desempenho em RAM. É ideal para armazenar em cache resultados de consultas de banco de dados, sessões de usuário e fragmentos HTML.

Instalação e Conexão do Memcached

Primeiro, instale o servidor Memcached e o cliente para Node.js:

# Install server (Ubuntu/Debian)sudo apt-get install memcached

# Install client for Node.jsnpm install memcached

Exemplo de Trabalho com Memcached em Node.js

const Memcached = require('memcached');const memcached = new Memcached('localhost:11211');

// Save data with TTL (in seconds)memcached.set('user:456', { name: 'Ivan', email: 'ivan@example.com' }, 3600, (err) => {  if (err) console.error('Error saving:', err);});

// Get datamemcached.get('user:456', (err, data) => {  if