In-memory caching with node-cache in Express - Step-by-Step Execution

Concept Flow - In-memory caching with node-cache

Start Express Server

↓

Receive HTTP Request

↓

Check Cache for Key

↓

Return Cached Data

↓

Send Response

↓

End Request

This flow shows how a server checks the cache first, returns cached data if found, or fetches fresh data and caches it before responding.

Execution Sample

Express

const NodeCache = require('node-cache');
const cache = new NodeCache({ stdTTL: 10 });

app.get('/data', (req, res) => {
  const key = 'myData';
  const cached = cache.get(key);
  if (cached !== undefined) return res.send(cached);
  const freshData = { value: 42 };
  cache.set(key, freshData);
  res.send(freshData);
});

This code checks if 'myData' is cached; if yes, returns it; if no, creates fresh data, caches it, then returns it.

Execution Table

Step	Action	Cache State	Response Sent	Notes
1	Request '/data' received	{}	No	Cache empty initially
2	Check cache for 'myData'	{}	No	'myData' not found
3	Create freshData {value:42}	{}	No	Prepare data to cache
4	Set 'myData' in cache	{'myData': {value:42}}	No	Data cached with TTL 10s
5	Send freshData in response	{'myData': {value:42}}	Yes	Response sent with fresh data
6	Next request '/data' received	{'myData': {value:42}}	No	Cache has data now
7	Check cache for 'myData'	{'myData': {value:42}}	No	'myData' found in cache
8	Send cached data in response	{'myData': {value:42}}	Yes	Response sent with cached data
9	After 10s TTL expires	{}	No	Cache entry expired and removed

💡 Cache returns data if found; otherwise, fresh data is cached and returned. Cache entries expire after TTL.

Variable Tracker

Variable	Start	After Step 4	After Step 7	After Step 9
cache	{}	{'myData': {value:42}}	{'myData': {value:42}}	{}
cached	undefined	undefined	{value:42}	undefined
freshData	undefined	{value:42}	undefined	undefined

Key Moments - 3 Insights

Why does the server return cached data on the second request?

Because at step 7 in the execution table, the cache contains 'myData', so the server sends cached data without creating fresh data.

What happens when the cache TTL expires?

At step 9, the cache entry for 'myData' is removed automatically, so the cache becomes empty and fresh data will be created on the next request.

Why do we check the cache before fetching fresh data?

Checking the cache first (steps 2 and 7) avoids unnecessary data fetching, improving speed and reducing load.

Visual Quiz - 3 Questions

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

A undefined

B {}

C {'myData': {value:42}}

D {'myData': undefined}

💡 Hint

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

At which step does the server send cached data in response?

A Step 5

B Step 8

C Step 7

D Step 3

💡 Hint

Look for 'Send cached data in response' in the 'Action' column.

If the TTL was set to 0 (no expiration), what would happen at step 9?

A Cache would still contain 'myData'

B Cache would still be empty

C Cache would throw an error

D Cache would delete 'myData' immediately

💡 Hint

Refer to the 'Cache State' changes and TTL behavior in the variable_tracker.

Concept Snapshot

In-memory caching with node-cache:
- Create cache with TTL (time to live)
- On request, check cache for key
- If found, return cached data
- If not, fetch fresh data, cache it, then return
- Cached data expires after TTL
- Speeds up repeated requests by avoiding repeated data fetching

Full Transcript

This lesson shows how an Express server uses node-cache to store data in memory temporarily. When a request comes in, the server first checks if the data is already cached. If yes, it sends the cached data immediately. If not, it creates fresh data, stores it in the cache, and then sends it. The cache entries expire after a set time (TTL), so old data is removed automatically. This process helps the server respond faster to repeated requests by avoiding repeated data fetching.

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)