In-memory caching patterns in Node.js - Step-by-Step Execution

Concept Flow - In-memory caching patterns

Request comes in

↓

Check cache for data

↓

Return cached

↓

Send response

↓

Send response

This flow shows how a request first checks the cache. If data is found, it returns immediately. If not, it fetches from the source, stores it in cache, then returns.

Execution Sample

Node.js

const cache = new Map();

async function getData(key) {
  if (cache.has(key)) return cache.get(key);
  const data = await fetchFromDB(key);
  cache.set(key, data);
  return data;
}

This code checks if data is in cache. If yes, returns it. Otherwise, fetches from DB, caches it, then returns.

Execution Table

Step	Action	Cache State	Result
1	Call getData('user1')	{}	Cache miss, fetch from DB
2	Fetch data for 'user1'	{}	{ name: 'Alice' }
3	Store 'user1' data in cache	{ 'user1': { name: 'Alice' } }	Data cached
4	Return data for 'user1'	{ 'user1': { name: 'Alice' } }	{ name: 'Alice' }
5	Call getData('user1') again	{ 'user1': { name: 'Alice' } }	Cache hit, return cached data
6	Return cached data for 'user1'	{ 'user1': { name: 'Alice' } }	{ name: 'Alice' }

💡 After second call, data is returned from cache, no DB fetch needed.

Variable Tracker

Variable	Start	After Step 3	After Step 6
cache	{}	{ 'user1': { name: 'Alice' } }	{ 'user1': { name: 'Alice' } }

Key Moments - 2 Insights

Why does the second call to getData('user1') not fetch from the DB again?

Because the cache already contains 'user1' data after step 3, so at step 5 the function returns cached data immediately without fetching.

What happens if the cache does not have the requested key?

The function fetches data from the source (DB), stores it in cache (step 3), then returns it (step 4), as shown in the execution table.

Visual Quiz - 3 Questions

Look at the execution table, what is the cache state after step 3?

A { 'user2': { name: 'Bob' } }

B { 'user1': { name: 'Alice' } }

C {}

D null

💡 Hint

Check the 'Cache State' column at step 3 in the execution table.

At which step does the function return cached data instead of fetching from DB?

A Step 5

B Step 2

C Step 1

D Step 4

💡 Hint

Look for 'Cache hit' in the 'Result' column of the execution table.

If we clear the cache before step 5, what would happen at step 5?

A Return cached data

B Throw an error

C Fetch from DB again

D Return null

💡 Hint

Refer to the cache state in variable_tracker and what happens on cache miss in execution_table.

Concept Snapshot

In-memory caching stores data in memory for fast access.
Check cache first before fetching from slow source.
If cache miss, fetch data, store in cache, then return.
Use simple Map or object for cache in Node.js.
Improves performance by avoiding repeated fetches.

Full Transcript

In-memory caching is a pattern where data is stored temporarily in the program's memory to speed up repeated access. When a request for data comes in, the program first checks if the data is already in the cache. If it is, it returns the cached data immediately, saving time. If not, it fetches the data from a slower source like a database, stores it in the cache, and then returns it. This way, subsequent requests for the same data are faster. The example code uses a Map object as the cache. The execution table shows the steps: first call misses cache and fetches data, second call hits cache and returns data quickly. This pattern helps improve performance and reduce load on external data sources.

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