In-memory caching with node-cache in Express - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this caching example?

Consider this Express route using node-cache. What will be the response when the route is called twice in a row?

Express

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

const app = express();
const cache = new NodeCache({ stdTTL: 5 });

app.get('/data', (req, res) => {
  const cachedData = cache.get('key');
  if (cachedData) {
    return res.send(`Cached: ${cachedData}`);
  }
  const data = 'fresh-data';
  cache.set('key', data);
  res.send(`New: ${data}`);
});

A Both calls return 'Cached: fresh-data'

B First call: 'Cached: fresh-data', second call: 'New: fresh-data'

C Both calls return 'New: fresh-data'

D First call: 'New: fresh-data', second call: 'Cached: fresh-data'

💡 Hint

Think about what happens when the cache is empty and then filled.

On the first call, the cache is empty, so the route sets and returns fresh data. On the second call, the cache has the data, so it returns the cached value.

❓ state_output

intermediate

What is the cache size after these operations?

Given this code snippet using node-cache, how many keys remain in the cache after execution?

Express

import NodeCache from 'node-cache';
const cache = new NodeCache({ stdTTL: 2 });

cache.set('a', 1);
cache.set('b', 2);
setTimeout(() => {
  cache.set('c', 3);
}, 1500);

setTimeout(() => {
  console.log(cache.keys().length);
}, 3000);

A 1

B 2

C 3

D 0

💡 Hint

Remember the TTL and when keys expire.

Keys 'a' and 'b' expire after 2 seconds. 'c' is set after 1.5 seconds and still valid at 3 seconds, so only 'c' remains.

🔧 Debug

advanced

Why does this cache retrieval always return undefined?

Look at this Express route using node-cache. Why does it always respond with 'Cache miss' even after setting the value?

Express

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

const app = express();
const cache = new NodeCache();

app.get('/item', (req, res) => {
  const value = cache.get('item');
  if (value) {
    return res.send(`Cached: ${value}`);
  }
  cache.set('item', 'value');
  res.send('Cache miss');
});

A Because the key 'item' is misspelled in cache.get compared to cache.set.

B Because cache.get returns undefined if the key is not found, so the first call returns 'Cache miss' but subsequent calls return 'Cached: value'.

C Because the cache instance is recreated on every request, so the cache is always empty.

D Because cache.set is asynchronous and the value is not set before cache.get runs.

💡 Hint

Check if the cache instance is reused and if set/get are synchronous.

The cache instance is created once and reused. cache.set is synchronous. The first call finds no key and returns 'Cache miss'. Later calls find the cached value and return it.

📝 Syntax

advanced

Which option correctly sets a cache with a custom TTL?

You want to store a key 'user' with value 'Alice' in node-cache with a TTL of 10 seconds. Which code is correct?

A cache.set('user', 'Alice', ttl=10);

B cache.set('user', 'Alice', { ttl: 10 });

C cache.set('user', 'Alice', 10);

D cache.set('user', 'Alice', ttl: 10);

💡 Hint

Check the node-cache set method signature for TTL parameter.

The set method accepts key, value, and optional ttl as a number in seconds. Option C uses the correct syntax.

🧠 Conceptual

expert

What happens if you set a key with TTL 0 in node-cache?

In node-cache, what is the behavior when you set a key with TTL value 0?

A The key is stored permanently and never expires unless deleted manually.

B The key expires immediately and is removed from the cache.

C Setting TTL 0 causes a runtime error.

D The key is stored with the default TTL set in the cache constructor.

💡 Hint

Think about what TTL 0 means in caching terms.

TTL 0 means no expiration, so the key stays in cache until manually deleted or cache is cleared.