In-memory caching patterns in Node.js

Introduction

In-memory caching stores data temporarily inside your app's memory. It helps your app get data faster without asking a database every time.

When you want to speed up repeated data requests in your app.

When your app needs quick access to data that doesn't change often.

When you want to reduce load on your database or external services.

When you want to store session or user info temporarily during a user visit.

Syntax

Node.js

const cache = new Map();

// Save data
cache.set(key, value);

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

// Check if key exists
const hasKey = cache.has(key);

// Remove data
cache.delete(key);

// Clear all cache
cache.clear();

Map is a built-in JavaScript object good for simple in-memory caching.

You can use any string or object as a key in Map.

Examples

Store and get a user object by key 'user_1'.

Node.js

cache.set('user_1', { name: 'Alice', age: 25 });
const user = cache.get('user_1');

Check if 'settings' data is already cached before using it.

Node.js

if (cache.has('settings')) {
  console.log('Settings found in cache');
}

Remove 'temp_data' from cache when no longer needed.

Node.js

cache.delete('temp_data');

Clear all cached data, useful when resetting app state.

Node.js

cache.clear();

Sample Program

This Node.js server caches the current time when you visit /time. The first request stores the time, and later requests return the cached time quickly. Visiting /clear clears the cache.

Node.js

import http from 'node:http';

const cache = new Map();

const server = http.createServer((req, res) => {
  const url = req.url || '';

  if (url === '/time') {
    if (cache.has('time')) {
      res.writeHead(200, { 'Content-Type': 'text/plain' });
      res.end(`Cached time: ${cache.get('time')}`);
    } else {
      const now = new Date().toISOString();
      cache.set('time', now);
      res.writeHead(200, { 'Content-Type': 'text/plain' });
      res.end(`New time cached: ${now}`);
    }
  } else if (url === '/clear') {
    cache.clear();
    res.writeHead(200, { 'Content-Type': 'text/plain' });
    res.end('Cache cleared');
  } else {
    res.writeHead(404, { 'Content-Type': 'text/plain' });
    res.end('Not found');
  }
});

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

Important Notes

In-memory cache is fast but resets when the app restarts.

Use cache carefully to avoid stale data by adding expiration if needed.

For bigger apps, consider dedicated caching tools like Redis.

Summary

In-memory caching stores data inside your app for quick reuse.

Use JavaScript's Map for simple cache storage and retrieval.

Remember cache clears on app restart and may need expiration logic.

Practice

1. What is the main purpose of using in-memory caching in a Node.js application?

easy

A. To send data over the network

B. To permanently save data to disk

C. To encrypt data for security

D. To store data temporarily for faster access during runtime

Solution

1. Step 1: Understand caching purpose

   In-memory caching stores data temporarily inside the app to avoid repeated slow operations.

2. Step 2: Differentiate from other storage types

   Permanent storage is done on disk, not in-memory cache. Network and encryption are unrelated here.

3. Final Answer:

   To store data temporarily for faster access during runtime -> Option D

4. Quick Check:

   In-memory cache = temporary fast storage [OK]

Hint: Cache means fast temporary storage in app memory [OK]

Common Mistakes:

• Confusing cache with permanent disk storage
• Thinking cache sends data over network
• Assuming cache encrypts data

2. Which of the following is the correct way to create a simple in-memory cache using JavaScript's Map in Node.js?

easy

A. const cache = Map();

B. const cache = {};

C. const cache = new Map();

D. const cache = new map();

Solution

1. Step 1: Recall Map object creation syntax

   JavaScript's Map is created with new Map(), capital M and parentheses.

2. Step 2: Check options for syntax correctness

   const cache = new Map(); uses correct syntax. const cache = Map(); misses new keyword. const cache = {}; uses object literal, not Map. const cache = new map(); uses lowercase 'map' which is invalid.

3. Final Answer:

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

4. Quick Check:

   Map creation = new Map() [OK]

Hint: Use 'new Map()' with capital M and parentheses [OK]

Common Mistakes:

• Omitting 'new' keyword
• Using lowercase 'map' instead of 'Map'
• Confusing Map with plain object {}

3. Consider this Node.js code using a Map as cache:

const cache = new Map();
cache.set('user1', {name: 'Alice'});
cache.set('user2', {name: 'Bob'});
console.log(cache.get('user1').name);

What will be printed to the console?

medium

A. Alice

B. undefined

C. user1

D. Error: Cannot read property 'name' of undefined

Solution

1. Step 1: Understand cache.set and cache.get usage

   cache.set('user1', {name: 'Alice'}) stores an object with name 'Alice' under key 'user1'.

2. Step 2: Retrieve and access property

   cache.get('user1') returns the object {name: 'Alice'}, so accessing .name gives 'Alice'.

3. Final Answer:

   Alice -> Option A

4. Quick Check:

   cache.get('user1').name = Alice [OK]

Hint: cache.get(key) returns stored value; access properties normally [OK]

Common Mistakes:

• Assuming cache.get returns key instead of value
• Forgetting to use .name on the returned object
• Thinking cache.get returns undefined if key exists

4. This code snippet tries to implement a cache but has a bug:

const cache = new Map();
function getData(key) {
  if (cache.has(key)) {
    return cache.get;
  }
  const data = fetchFromDb(key);
  cache.set(key, data);
  return data;
}

What is the bug causing incorrect cache retrieval?

medium

A. fetchFromDb should be awaited with async

B. cache.get is a function reference, should call cache.get(key)

C. cache.set(key, data) should be cache.add(key, data)

D. cache.has(key) should be cache.exists(key)

Solution

1. Step 1: Analyze cache retrieval line

   cache.get is a function, but code returns cache.get without calling it with key.

2. Step 2: Correct method usage

   It should be cache.get(key) to retrieve the cached value properly.

3. Final Answer:

   cache.get is a function reference, should call cache.get(key) -> Option B

4. Quick Check:

   Use cache.get(key) to get value [OK]

Hint: Call cache.get with key: cache.get(key) [OK]

Common Mistakes:

• Returning cache.get without parentheses
• Using non-existent cache.exists method
• Confusing cache.set with cache.add

5. You want to implement an in-memory cache in Node.js that automatically removes entries after 5 seconds to save memory. Which approach correctly adds expiration logic?

hard

A. Use Map and setTimeout to delete the key after 5 seconds when setting cache

B. Use Map and clear the entire cache every 5 seconds with setInterval

C. Use a plain object and rely on garbage collection to remove old keys

D. Use Map and never delete keys to keep cache forever

Solution

1. Step 1: Understand expiration requirement

   We want each cache entry to be removed individually after 5 seconds.

2. Step 2: Evaluate options for expiration logic

   Use Map and setTimeout to delete the key after 5 seconds when setting cache uses setTimeout per key to delete it after 5 seconds, which fits requirement. Use Map and clear the entire cache every 5 seconds with setInterval clears entire cache, not per key. Use a plain object and rely on garbage collection to remove old keys relies on garbage collection which does not remove keys automatically. Use Map and never delete keys to keep cache forever never deletes keys, so no expiration.

3. Final Answer:

   Use Map and setTimeout to delete the key after 5 seconds when setting cache -> Option A

4. Quick Check:

   Use setTimeout per key for expiration [OK]

Hint: Use setTimeout to delete each key after delay [OK]

Common Mistakes:

• Clearing whole cache instead of individual keys
• Expecting garbage collection to remove keys automatically
• Not deleting keys causes memory bloat