In-memory caching patterns in Node.js - Mini Project: Build & Apply

In-memory caching patterns in Node.js

📖 Scenario: You are building a simple Node.js app that fetches user data from a slow database. To speed up repeated requests, you want to store user data temporarily in memory.

🎯 Goal: Build a basic in-memory cache using a JavaScript object to store user data keyed by user ID. Implement cache lookup, cache insertion, and cache expiration logic.

📋 What You'll Learn

Create an object called cache to hold cached user data

Create a variable called cacheDuration set to 30000 (milliseconds)

Write a function getUserFromCache that returns cached data if not expired

Write a function setUserInCache that stores user data with a timestamp

Add logic to check cache expiration before returning cached data

💡 Why This Matters

🌍 Real World

In-memory caching is used in web servers to speed up repeated data requests and reduce database load.

💼 Career

Understanding caching patterns is important for backend developers to improve application performance and scalability.

1

Create the cache storage object

Create an empty object called cache to store cached user data.

Node.js

// Create an empty object called cache
// Your code here

Hint

Use const cache = {} to create an empty object.

2

Set cache duration time

Create a variable called cacheDuration and set it to 30000 milliseconds (30 seconds).

Node.js

const cache = {}
// Create cacheDuration variable and set to 30000
// Your code here

Hint

Use const cacheDuration = 30000; to set the cache time.

3

Write function to get user from cache

Write a function called getUserFromCache that takes userId as a parameter. It should check if cache[userId] exists and if the cached timestamp is within cacheDuration. Return the cached data if valid, otherwise return null.

Node.js

const cache = {};
const cacheDuration = 30000;

// Write getUserFromCache function
// Your code here

Hint

Check if cache[userId] exists and if Date.now() - cached.timestamp < cacheDuration. Return cached data or null.

4

Write function to set user in cache

Write a function called setUserInCache that takes userId and userData as parameters. It should store an object in cache[userId] with data set to userData and timestamp set to the current time using Date.now().

Node.js

const cache = {};
const cacheDuration = 30000;

function getUserFromCache(userId) {
    const cached = cache[userId];
    if (cached) {
        const isValid = (Date.now() - cached.timestamp) < cacheDuration;
        if (isValid) {
            return cached.data;
        }
    }
    return null;
}

// Write setUserInCache function
// Your code here

Hint

Store an object with data and timestamp in cache[userId].

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