Why caching improves performance in Express - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to set a cache-control header that tells browsers to cache the response for 1 hour.

Express

app.get('/data', (req, res) => {
  res.set('Cache-Control', '[1]');
  res.send('Cached data');
});

Drag options to blanks, or click blank then click option'

Apublic, max-age=3600

Bno-cache

Cno-store

Dprivate, max-age=0

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'no-cache' disables caching, which hurts performance.

Setting Cache-Control to public, max-age=3600 tells browsers to cache the response for 3600 seconds (1 hour), improving performance by avoiding repeated requests.

2fill in blank

medium

Complete the code to use an in-memory cache object to store and return data if available.

Express

const cache = {};
app.get('/info', (req, res) => {
  if (cache['info']) {
    return res.send(cache['[1]']);
  }
  const data = 'Fresh info';
  cache['info'] = data;
  res.send(data);
});

Drag options to blanks, or click blank then click option'

Areq

Bdata

Cinfo

Dcache

Attempts:

3 left

💡 Hint

Common Mistakes

Using a wrong key like 'data' or 'cache' causes undefined results.

The cache key is 'info', so to return cached data, use cache['info']. This avoids recomputing or fetching data again, improving response time.

3fill in blank

hard

Fix the error in the middleware that caches responses by completing the missing method to send the cached data.

Express

const cache = {};
app.use((req, res, next) => {
  if (cache[req.url]) {
    return res.[1](cache[req.url]);
  }
  next();
});

Drag options to blanks, or click blank then click option'

Asend

Bwrite

Cjson

Dend

Attempts:

3 left

💡 Hint

Common Mistakes

Using res.write() without ending the response causes hanging requests.

The res.send() method sends the cached response to the client properly. Using write or end alone won't set headers or finish the response correctly.

4fill in blank

hard

Fill both blanks to create a cache key using the request method and URL.

Express

app.use((req, res, next) => {
  const key = req.[1] + ':' + req.[2];
  if (cache[key]) {
    return res.send(cache[key]);
  }
  next();
});

Drag options to blanks, or click blank then click option'

Amethod

Burl

Cpath

Dquery

Attempts:

3 left

💡 Hint

Common Mistakes

Using req.path alone misses query parameters, causing cache misses.

Using req.method and req.url creates a unique cache key for each HTTP method and URL combination, ensuring correct cached responses.

5fill in blank

hard

Fill all three blanks to store the response data in cache and send it after the original send method.

Express

app.use((req, res, next) => {
  const key = req.method + ':' + req.url;
  const originalSend = res.[1];
  res.[2] = function (body) {
    cache[key] = body;
    return originalSend.call(this, [3]);
  };
  next();
});

Drag options to blanks, or click blank then click option'

Asend

Cbody

Dres

Attempts:

3 left

💡 Hint

Common Mistakes

Calling originalSend without .call or passing wrong argument causes errors.

We save the original res.send method in originalSend (option A). Then override res.send (option B) to cache the body (option C) before sending it. This caches responses transparently.

Practice

1. Why does caching improve performance in an Express app?

easy

A. It slows down the server to handle more requests

B. It increases the size of the server's memory permanently

C. It stores data temporarily to avoid repeating expensive operations

D. It deletes old data to free up space immediately

Solution

1. Step 1: Understand caching purpose

   Caching saves results of expensive operations temporarily so they can be reused.

2. Step 2: Relate caching to performance

   By reusing stored data, the server avoids repeating slow tasks, speeding up responses.

3. Final Answer:

   It stores data temporarily to avoid repeating expensive operations -> Option C

4. Quick Check:

   Caching = Temporary storage for speed [OK]

Hint: Caching saves repeated work to speed up responses [OK]

Common Mistakes:

• Thinking caching permanently increases memory
• Believing caching slows down the server
• Confusing caching with deleting data

2. Which Express middleware syntax correctly sets a simple cache header for 1 hour?

easy

A. res.cacheControl('3600')

B. res.set('Cache-Control', 'max-age=3600')

C. res.header('Cache-Control', 'no-cache')

D. res.cache('max-age=3600')

Solution

1. Step 1: Identify correct Express method

   Express uses res.set() or res.header() to set headers; res.set() is common.

2. Step 2: Check cache header format

   'Cache-Control' with 'max-age=3600' sets cache for 3600 seconds (1 hour).

3. Final Answer:

   res.set('Cache-Control', 'max-age=3600') -> Option B

4. Quick Check:

   Correct header syntax = res.set('Cache-Control', 'max-age=3600') [OK]

Hint: Use res.set() with 'Cache-Control' header [OK]

Common Mistakes:

• Using non-existent res.cache() method
• Setting 'no-cache' disables caching
• Wrong method names like res.cacheControl()

3. Consider this Express route with caching logic:

app.get('/data', (req, res) => {
  if (cache.data) {
    res.send(cache.data);
  } else {
    const result = expensiveCalculation();
    cache.data = result;
    res.send(result);
  }
});

What happens on the second request to '/data'?

medium

A. The server sends cached data without recalculating

B. The server runs expensiveCalculation() again

C. The server returns an error because cache.data is undefined

D. The server sends an empty response

Solution

1. Step 1: Analyze first request behavior

   On first request, cache.data is empty, so expensiveCalculation() runs and result is cached.

2. Step 2: Analyze second request behavior

   On second request, cache.data exists, so server sends cached data directly without recalculating.

3. Final Answer:

   The server sends cached data without recalculating -> Option A

4. Quick Check:

   Cache hit = reuse data [OK]

Hint: Cached data skips recalculation on repeat requests [OK]

Common Mistakes:

• Assuming calculation runs every time
• Thinking cache.data is undefined on second request
• Believing server sends empty response

4. This Express caching code has a bug:

app.get('/info', (req, res) => {
  if (cache.info) {
    res.send(cache.info);
  } else {
    const data = fetchData();
    cache.info = data;
    res.send(data);
  }
});

fetchData() is asynchronous and returns a Promise. What is the main issue?

medium

A. fetchData() blocks the server, causing timeout

B. cache.info is never set, causing infinite loop

C. res.send() cannot send strings

D. res.send() is called before fetchData() resolves, sending a Promise object

Solution

1. Step 1: Identify async function usage

   fetchData() returns a Promise but code treats it as synchronous.

2. Step 2: Understand res.send() timing

   res.send(data) runs immediately, sending the unresolved Promise, not actual data.

3. Final Answer:

   res.send() is called before fetchData() resolves, sending a Promise object -> Option D

4. Quick Check:

   Async function needs await before sending [OK]

Hint: Await async calls before sending response [OK]

Common Mistakes:

• Ignoring async nature of fetchData()
• Assuming cache is never set
• Thinking res.send() can't send strings

5. You want to cache user profile data in Express but ensure it updates every 10 minutes. Which approach best balances caching and data freshness?

hard

A. Store data in cache with a timestamp; refresh cache if older than 10 minutes

B. Cache data forever without expiration to maximize speed

C. Never cache user data to always get fresh info

D. Clear cache manually only when server restarts

Solution

1. Step 1: Understand caching with expiration

   To keep data fresh, cache should have a time limit after which it refreshes.

2. Step 2: Evaluate options for freshness and speed

   Store data in cache with a timestamp; refresh cache if older than 10 minutes uses timestamp to refresh cache every 10 minutes, balancing speed and freshness.

3. Final Answer:

   Store data in cache with a timestamp; refresh cache if older than 10 minutes -> Option A

4. Quick Check:

   Timed cache refresh = Store data in cache with a timestamp; refresh cache if older than 10 minutes [OK]

Hint: Use timestamps to refresh cache periodically [OK]

Common Mistakes:

• Caching forever causes stale data
• Never caching loses speed benefits
• Manual cache clearing is unreliable