In-memory caching with node-cache in Express

Introduction

In-memory caching stores data temporarily in your app's memory. It helps your app respond faster by reusing data instead of fetching it again.

You want to speed up repeated requests for the same data.

You want to reduce calls to a slow database or external API.

You want to store small data temporarily during app runtime.

You want to improve user experience by reducing wait times.

You want to limit resource use by avoiding repeated heavy calculations.

Syntax

Express

import NodeCache from 'node-cache';

const cache = new NodeCache({ stdTTL: 100, checkperiod: 120 });

// Set a value
cache.set(key, value, ttlInSeconds);

// Get a value
const value = cache.get(key);

// Delete a value
cache.del(key);

stdTTL sets default time to live (seconds) for cached items.

checkperiod is how often expired items are cleaned up.

Examples

Stores user data with key 'user_1' for 5 minutes.

Express

cache.set('user_1', { name: 'Alice' }, 300);

Retrieves cached user data and checks if it exists.

Express

const user = cache.get('user_1');
if (user) {
  console.log('User found:', user.name);
} else {
  console.log('User not in cache');
}

Removes the cached data for 'user_1'.

Express

cache.del('user_1');

Sample Program

This Express app uses node-cache to store data for 60 seconds. When you request '/data', it first checks the cache. If data is there, it returns cached data quickly. If not, it creates fresh data, caches it, and returns it.

Express

import express from 'express';
import NodeCache from 'node-cache';

const app = express();
const cache = new NodeCache({ stdTTL: 60 }); // cache items live 60 seconds

app.get('/data', (req, res) => {
  const key = 'myData';
  const cachedData = cache.get(key);

  if (cachedData) {
    return res.send({ source: 'cache', data: cachedData });
  }

  // Simulate slow data fetch
  const freshData = { message: 'Hello from server', time: new Date().toISOString() };

  cache.set(key, freshData);
  res.send({ source: 'server', data: freshData });
});

app.listen(3000, () => {
  console.log('Server running on http://localhost:3000');
});

Important Notes

Cache is stored in app memory, so it resets if the app restarts.

Use caching only for data that can be temporarily stored and safely reused.

Be mindful of cache size and expiration to avoid memory issues.

Summary

In-memory caching speeds up your app by storing data temporarily.

node-cache is a simple tool to add caching in Node.js apps.

Always check cache before fetching fresh data to save time.

Practice

1. What is the main purpose of using node-cache in an Express app?

easy

A. To permanently save data to a database

B. To temporarily store data in memory for faster access

C. To handle user authentication securely

D. To serve static files like images and CSS

Solution

1. Step 1: Understand what caching means

   Caching means storing data temporarily to avoid repeated slow operations.

2. Step 2: Identify node-cache role in Express

   node-cache stores data in memory temporarily to speed up data retrieval.

3. Final Answer:

   To temporarily store data in memory for faster access -> Option B

4. Quick Check:

   In-memory caching = temporary fast storage [OK]

Hint: Cache stores data temporarily to speed up access [OK]

Common Mistakes:

• Confusing cache with permanent database storage
• Thinking node-cache handles authentication
• Assuming node-cache serves static files

2. Which of the following is the correct way to create a new cache instance using node-cache?

easy

A. const cache = new nodeCache();

B. const cache = nodeCache.create();

C. const cache = new NodeCache();

D. const cache = NodeCache();

Solution

1. Step 1: Recall node-cache import and usage

   node-cache is imported as NodeCache and instantiated with new keyword.

2. Step 2: Check syntax correctness

   Correct syntax is: const cache = new NodeCache();

3. Final Answer:

   const cache = new NodeCache(); -> Option C

4. Quick Check:

   Use new NodeCache() to create cache [OK]

Hint: Use 'new' keyword with NodeCache class [OK]

Common Mistakes:

• Calling nodeCache.create() which does not exist
• Using lowercase 'nodeCache' instead of 'NodeCache'
• Omitting 'new' keyword when creating instance

3. Given the code snippet below, what will be the output when accessing /data twice quickly?

const express = require('express');
const NodeCache = require('node-cache');
const app = express();
const cache = new NodeCache();

app.get('/data', (req, res) => {
  const cached = cache.get('myData');
  if (cached) {
    res.send('From cache: ' + cached);
  } else {
    const freshData = 'Hello World';
    cache.set('myData', freshData, 10);
    res.send('Fresh data: ' + freshData);
  }
});

app.listen(3000);

medium

A. First request: Fresh data: Hello World; Second request: From cache: Hello World

B. Both requests: Fresh data: Hello World

C. Both requests: From cache: Hello World

D. First request: From cache: Hello World; Second request: Fresh data: Hello World

Solution

1. Step 1: Analyze cache check on first request

   Cache is empty initially, so first request sets and returns fresh data.

2. Step 2: Analyze cache check on second request

   Second request finds data in cache and returns cached data.

3. Final Answer:

   First request: Fresh data: Hello World; Second request: From cache: Hello World -> Option A

4. Quick Check:

   Cache empty first, then hit cache second [OK]

Hint: First request sets cache, second reads from cache [OK]

Common Mistakes:

• Assuming cache is always empty
• Thinking cache returns fresh data every time
• Mixing order of fresh and cached responses

4. Identify the error in this code snippet using node-cache in Express:

const NodeCache = require('node-cache');
const cache = NodeCache();

app.get('/item', (req, res) => {
  const item = cache.get('itemKey');
  if (!item) {
    cache.set('itemKey', 'value');
    res.send('Set new item');
  } else {
    res.send('Cached item: ' + item);
  }
});

medium

A. Cache key 'itemKey' is invalid

B. Express app is not imported

C. cache.set requires a callback function

D. Missing 'new' keyword when creating cache instance

Solution

1. Step 1: Check cache instance creation

   node-cache requires 'new NodeCache()' to create an instance.

2. Step 2: Identify missing 'new' keyword

   Code uses 'NodeCache()' without 'new', causing error.

3. Final Answer:

   Missing 'new' keyword when creating cache instance -> Option D

4. Quick Check:

   Always use 'new' with NodeCache [OK]

Hint: Remember 'new' keyword for NodeCache instance [OK]

Common Mistakes:

• Forgetting 'new' keyword
• Thinking cache.set needs callback
• Assuming cache keys must be special format

5. You want to cache user profile data for 5 minutes using node-cache. Which code snippet correctly sets the cache with expiration and retrieves it safely in Express?

hard

A. cache.set('user1', profile, 300); const data = cache.get('user1'); if (data) res.send(data); else res.send('No cache');

B. cache.set('user1', profile); const data = cache.get('user1', 300); if (data) res.send(data); else res.send('No cache');

C. cache.set('user1', profile, 5); const data = cache.get('user1'); if (data) res.send(data); else res.send('No cache');

D. cache.set('user1', profile, 300000); const data = cache.get('user1'); if (data) res.send(data); else res.send('No cache');

Solution

1. Step 1: Understand TTL unit in node-cache

   TTL (time to live) is in seconds, so 5 minutes = 300 seconds.

2. Step 2: Check correct usage of set and get

   cache.set(key, value, ttl) sets with expiration; cache.get(key) retrieves value.

3. Final Answer:

   cache.set('user1', profile, 300); const data = cache.get('user1'); if (data) res.send(data); else res.send('No cache'); -> Option A

4. Quick Check:

   TTL in seconds, set with 300 for 5 minutes [OK]

Hint: TTL is seconds; 5 minutes = 300 seconds [OK]

Common Mistakes:

• Using TTL in milliseconds instead of seconds
• Passing TTL to get() method incorrectly
• Setting TTL too low (5 seconds instead of 300)