In-memory caching with node-cache in Express - Mini Project: Build & Apply

In-memory caching with node-cache in Express

📖 Scenario: You are building a simple Express server that fetches user data. To make it faster, you want to store some data temporarily in memory so the server does not fetch it again and again.

🎯 Goal: Create an Express server that uses node-cache to store user data in memory. The server should return cached data if available, or fetch and cache it if not.

📋 What You'll Learn

Create an Express app with a GET route at /user/:id

Use node-cache to store user data in memory

Set a cache time-to-live (TTL) of 10 seconds

Return cached data if it exists, otherwise simulate fetching data and cache it

💡 Why This Matters

🌍 Real World

In-memory caching helps speed up web servers by storing frequently requested data temporarily, reducing database or API calls.

💼 Career

Understanding caching is important for backend developers to improve app performance and scalability.

1

Setup Express app and import node-cache

Write code to import express and NodeCache from node-cache. Then create an Express app by calling express() and assign it to a variable called app.

Express

// Your code here

Hint

Use import statements to bring in the modules. Then call express() to create the app.

2

Create a cache instance with 10 seconds TTL

Create a new NodeCache instance called cache with a time-to-live (TTL) option set to 10 seconds.

Express

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

const app = express();

// Create cache instance with 10 seconds TTL
// Your code here

Hint

Use new NodeCache({ stdTTL: 10 }) to create the cache with 10 seconds TTL.

3

Add GET route to use cache for user data

Add a GET route handler on /user/:id using app.get. Inside the handler, get the id from req.params. Check if the user data exists in cache using cache.get(id). If it exists, return it as JSON. If not, simulate fetching user data by creating an object { id, name: `User ${id}` }, store it in cache with cache.set(id, userData), and return it as JSON.

Express

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

const app = express();

const cache = new NodeCache({ stdTTL: 10 });

// Add GET /user/:id route with caching
// Your code here

Hint

Use app.get with /user/:id. Use req.params.id to get the id. Use cache.get(id) to check cache. If no cache, create user data and store with cache.set(id, userData).

4

Start the Express server on port 3000

Add code to start the Express server by calling app.listen on port 3000. Provide a callback function that logs the message 'Server running on port 3000'.

Express

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

const app = express();

const cache = new NodeCache({ stdTTL: 10 });

app.get('/user/:id', (req, res) => {
  const id = req.params.id;
  const cachedUser = cache.get(id);
  if (cachedUser) {
    return res.json(cachedUser);
  }
  const userData = { id, name: `User ${id}` };
  cache.set(id, userData);
  res.json(userData);
});

// Start server on port 3000
// Your code here

Hint

Use app.listen(3000, () => { console.log('Server running on port 3000') }) to start the server.

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)