Why caching matters in Node.js - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why use caching in Node.js applications?

Which of the following best explains why caching is important in Node.js applications?

A Caching slows down the application to avoid overloading the server.

B Caching permanently saves all data to disk to prevent data loss.

C Caching deletes old files to free up disk space automatically.

D Caching stores data temporarily to reduce repeated processing and speed up response times.

💡 Hint

Think about how caching helps avoid doing the same work multiple times.

Caching temporarily stores data so the application can quickly reuse it without recalculating or fetching it again, improving speed and efficiency.

❓ component_behavior

intermediate

Effect of caching on repeated API calls

Consider a Node.js server that caches API responses in memory. What will happen when the same API endpoint is called multiple times quickly?

A The server will fetch fresh data from the source every time, causing delays.

B The server will return cached data after the first call, speeding up responses.

C The server will crash due to memory overflow from caching.

D The server will ignore the cache and send empty responses.

💡 Hint

Think about how caching avoids repeated work for the same request.

After the first API call, the server stores the response in cache. Subsequent calls return this cached data quickly without fetching again.

❓ state_output

advanced

Cache state after multiple requests

Given this Node.js cache object and sequence of requests, what is the final cache content?

const cache = {};

function getData(key) {
  if (cache[key]) {
    return cache[key];
  }
  const data = key.toUpperCase();
  cache[key] = data;
  return data;
}

getData('apple');
getData('banana');
getData('apple');
getData('cherry');

A {"apple": "APPLE", "banana": "BANANA", "cherry": "CHERRY"}

B {}

C {"APPLE": "APPLE", "BANANA": "BANANA", "CHERRY": "CHERRY"}

D {"apple": "apple", "banana": "banana", "cherry": "cherry"}

💡 Hint

Look at how keys and values are stored in the cache object.

The cache stores keys as given ('apple', 'banana', 'cherry') with values converted to uppercase strings.

📝 Syntax

advanced

Identify the syntax error in caching code

Which option contains a syntax error in this caching function?

function cacheResult(key, value) {
  cache[key] = value
  return cache[key];
}

A Missing semicolon after cache[key] = value

B Return statement is missing parentheses

C cache is not declared before use

D Function keyword is misspelled

💡 Hint

Check if all variables are declared before use.

The variable 'cache' is used but not declared anywhere, causing a ReferenceError at runtime.

🔧 Debug

expert

Why does this cache not improve performance?

Review this Node.js caching code snippet. Why does it fail to improve performance?

const cache = new Map();

function fetchData(key) {
  if (cache.has(key)) {
    return cache.get(key);
  }
  const data = expensiveCalculation(key);
  cache.set(key, data);
  return data;
}

function expensiveCalculation(key) {
  // Simulate heavy work
  for (let i = 0; i < 1e9; i++) {}
  return key * 2;
}

fetchData(5);
fetchData(5);

A The expensiveCalculation is synchronous and blocks the event loop on cache misses.

B The cache Map is cleared after each call, so no data is stored.

C The cache key is always different, so cache misses happen every time.

D The expensiveCalculation function returns undefined, so cache stores wrong data.

💡 Hint

Think about how synchronous blocking affects caching benefits.

Because expensiveCalculation blocks the event loop synchronously, the first call blocks the server. The second call benefits from cache but the blocking nature limits overall performance gains.