Why caching improves performance in Express - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

How does caching reduce server load in Express?

Imagine your Express server handles many requests for the same data. How does caching help reduce the server's work?

A Caching stores the data temporarily so the server can quickly send it without recalculating or fetching it again.

B Caching deletes old data to free up memory and speed up the server.

C Caching forces the server to process every request from scratch to ensure fresh data.

D Caching slows down the server by adding extra steps before sending data.

💡 Hint

Think about how remembering answers helps you avoid repeating work.

Caching keeps a copy of data so the server can reuse it quickly. This avoids repeated calculations or database calls, making responses faster and reducing server load.

❓ component_behavior

intermediate

What happens when Express serves cached content?

Consider an Express route that caches API responses. What is the main effect on response time when a cached response is available?

Express

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

A Response time is unpredictable because cache may cause errors.

B Response time is slower because the server checks the cache first.

C Response time is faster because data is sent directly from cache without waiting for the database.

D Response time is the same because the database is always queried.

💡 Hint

Think about skipping the slowest step.

Serving cached data skips the database call, which is usually slower. This makes the response faster.

🔧 Debug

advanced

Identify the caching mistake causing stale data in Express

Look at this Express caching code. Why might users see outdated data?

Express

const cache = new Map();

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

A The fetchLatestInfo function is asynchronous but used synchronously.

B The cache is cleared too often, causing frequent database calls.

C The cache key 'info' is misspelled, so cache is never used.

D The cache never expires, so old data stays forever without updates.

💡 Hint

Think about how long cached data stays valid.

Without a way to expire or refresh the cache, the server keeps sending old data, causing stale responses.

📝 Syntax

advanced

Which caching code snippet correctly caches JSON responses in Express?

Choose the code that properly caches and sends JSON data in Express.

A

app.get('/user', (req, res) => {
  if (cache.user) {
    res.json(cache.user);
  } else {
    const user = getUser();
    cache.user = user;
    res.json(user);
  }
});

B

app.get('/user', (req, res) => {
  if (cache.user) {
    res.send(JSON.stringify(cache.user));
  } else {
    const user = getUser();
    cache.user = JSON.stringify(user);
    res.send(user);
  }
});

C

app.get('/user', (req, res) => {
  if (cache.user) {
    res.json(JSON.parse(cache.user));
  } else {
    const user = getUser();
    cache.user = user;
    res.send(user);
  }
});

D

app.get('/user', (req, res) => {
  if (cache.user) {
    res.send(cache.user);
  } else {
    const user = getUser();
    cache.user = JSON.stringify(user);
    res.send(JSON.parse(cache.user));
  }
});

💡 Hint

Remember Express has a method to send JSON directly.

Option A caches the user object and uses res.json() to send JSON properly. Other options mix stringifying and parsing incorrectly or send raw objects improperly.

❓ state_output

expert

What is the cache state after multiple requests?

Given this Express caching code, what is the content of cache after three requests to /count?

Express

const cache = {};

app.get('/count', (req, res) => {
  if (!cache.count) {
    cache.count = 1;
  } else {
    cache.count += 1;
  }
  res.send(`Count is ${cache.count}`);
});

A {}

B {"count": 3}

C {"count": 0}

D {"count": 1}

💡 Hint

Each request increases the count by one if cached.

The cache starts empty. First request sets count to 1. Second increments to 2. Third increments to 3. So cache.count is 3 after three requests.