In-memory caching patterns in Node.js - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a simple in-memory cache object.

Node.js

const cache = {};

function setCache(key, value) {
  cache[[1]] = value;
}

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

Akey

Bvalue

Ccache

DsetCache

Attempts:

3 left

💡 Hint

Common Mistakes

Using the value instead of the key as the property name.

Trying to use the cache object itself as the key.

The cache stores values using the key as the property name. So we use key inside the brackets.

2fill in blank

medium

Complete the code to check if a key exists in the cache.

Node.js

function hasCache(key) {
  return [1] in cache;
}

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

Avalue

Bkey

Ccache

DsetCache

Attempts:

3 left

💡 Hint

Common Mistakes

Checking if the value is in the cache instead of the key.

Using the cache object on the left side of in incorrectly.

To check if a key exists in an object, use the in operator with the key.

3fill in blank

hard

Fix the error in the code to retrieve a cached value safely.

Node.js

function getCache(key) {
  if (cache.[1](key)) {
    return cache[key];
  }
  return null;
}

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

Acontains

Bincludes

CindexOf

DhasOwnProperty

Attempts:

3 left

💡 Hint

Common Mistakes

Using array methods like includes or indexOf on objects.

Using non-existent methods like contains on objects.

The hasOwnProperty method checks if the object has the key as its own property, which is safe for cache lookup.

4fill in blank

hard

Fill both blanks to implement a cache with expiration time.

Node.js

const cache = {};

function setCache(key, value, ttl) {
  cache[key] = { value: value, expiresAt: Date.now() + [1] };
}

function getCache(key) {
  const entry = cache[key];
  if (entry && entry.expiresAt > [2]) {
    return entry.value;
  }
  return null;
}

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

Attl

BDate.now()

CDate.now

DexpiresAt

Attempts:

3 left

💡 Hint

Common Mistakes

Using Date.now without parentheses, which is a function reference.

Comparing expiration with a wrong value instead of current time.

We add the ttl (time to live) to the current time to set expiration. When getting, we compare expiration with the current time using Date.now().

5fill in blank

hard

Fill all three blanks to implement a cache with a cleanup function that removes expired entries.

Node.js

const cache = {};

function setCache(key, value, ttl) {
  cache[key] = { value: value, expiresAt: Date.now() + [1] };
}

function cleanupCache() {
  const now = [2];
  for (const key in cache) {
    if (cache[key].expiresAt <= now) {
      [3] cache[key];
    }
  }
}

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

Attl

BDate.now()

Cdelete

Dcache

Attempts:

3 left

💡 Hint

Common Mistakes

Using Date.now without parentheses.

Trying to assign null instead of deleting the property.

Using wrong variable names in the loop.

The ttl is added to current time to set expiration. We get current time with Date.now(). To remove expired entries, we use the delete operator on the cache property.

Practice

1. What is the main purpose of using in-memory caching in a Node.js application?

easy

A. To send data over the network

B. To permanently save data to disk

C. To encrypt data for security

D. To store data temporarily for faster access during runtime

Solution

1. Step 1: Understand caching purpose

   In-memory caching stores data temporarily inside the app to avoid repeated slow operations.

2. Step 2: Differentiate from other storage types

   Permanent storage is done on disk, not in-memory cache. Network and encryption are unrelated here.

3. Final Answer:

   To store data temporarily for faster access during runtime -> Option D

4. Quick Check:

   In-memory cache = temporary fast storage [OK]

Hint: Cache means fast temporary storage in app memory [OK]

Common Mistakes:

• Confusing cache with permanent disk storage
• Thinking cache sends data over network
• Assuming cache encrypts data

2. Which of the following is the correct way to create a simple in-memory cache using JavaScript's Map in Node.js?

easy

A. const cache = Map();

B. const cache = {};

C. const cache = new Map();

D. const cache = new map();

Solution

1. Step 1: Recall Map object creation syntax

   JavaScript's Map is created with new Map(), capital M and parentheses.

2. Step 2: Check options for syntax correctness

   const cache = new Map(); uses correct syntax. const cache = Map(); misses new keyword. const cache = {}; uses object literal, not Map. const cache = new map(); uses lowercase 'map' which is invalid.

3. Final Answer:

   const cache = new Map(); -> Option C

4. Quick Check:

   Map creation = new Map() [OK]

Hint: Use 'new Map()' with capital M and parentheses [OK]

Common Mistakes:

• Omitting 'new' keyword
• Using lowercase 'map' instead of 'Map'
• Confusing Map with plain object {}

3. Consider this Node.js code using a Map as cache:

const cache = new Map();
cache.set('user1', {name: 'Alice'});
cache.set('user2', {name: 'Bob'});
console.log(cache.get('user1').name);

What will be printed to the console?

medium

A. Alice

B. undefined

C. user1

D. Error: Cannot read property 'name' of undefined

Solution

1. Step 1: Understand cache.set and cache.get usage

   cache.set('user1', {name: 'Alice'}) stores an object with name 'Alice' under key 'user1'.

2. Step 2: Retrieve and access property

   cache.get('user1') returns the object {name: 'Alice'}, so accessing .name gives 'Alice'.

3. Final Answer:

   Alice -> Option A

4. Quick Check:

   cache.get('user1').name = Alice [OK]

Hint: cache.get(key) returns stored value; access properties normally [OK]

Common Mistakes:

• Assuming cache.get returns key instead of value
• Forgetting to use .name on the returned object
• Thinking cache.get returns undefined if key exists

4. This code snippet tries to implement a cache but has a bug:

const cache = new Map();
function getData(key) {
  if (cache.has(key)) {
    return cache.get;
  }
  const data = fetchFromDb(key);
  cache.set(key, data);
  return data;
}

What is the bug causing incorrect cache retrieval?

medium

A. fetchFromDb should be awaited with async

B. cache.get is a function reference, should call cache.get(key)

C. cache.set(key, data) should be cache.add(key, data)

D. cache.has(key) should be cache.exists(key)

Solution

1. Step 1: Analyze cache retrieval line

   cache.get is a function, but code returns cache.get without calling it with key.

2. Step 2: Correct method usage

   It should be cache.get(key) to retrieve the cached value properly.

3. Final Answer:

   cache.get is a function reference, should call cache.get(key) -> Option B

4. Quick Check:

   Use cache.get(key) to get value [OK]

Hint: Call cache.get with key: cache.get(key) [OK]

Common Mistakes:

• Returning cache.get without parentheses
• Using non-existent cache.exists method
• Confusing cache.set with cache.add

5. You want to implement an in-memory cache in Node.js that automatically removes entries after 5 seconds to save memory. Which approach correctly adds expiration logic?

hard

A. Use Map and setTimeout to delete the key after 5 seconds when setting cache

B. Use Map and clear the entire cache every 5 seconds with setInterval

C. Use a plain object and rely on garbage collection to remove old keys

D. Use Map and never delete keys to keep cache forever

Solution

1. Step 1: Understand expiration requirement

   We want each cache entry to be removed individually after 5 seconds.

2. Step 2: Evaluate options for expiration logic

   Use Map and setTimeout to delete the key after 5 seconds when setting cache uses setTimeout per key to delete it after 5 seconds, which fits requirement. Use Map and clear the entire cache every 5 seconds with setInterval clears entire cache, not per key. Use a plain object and rely on garbage collection to remove old keys relies on garbage collection which does not remove keys automatically. Use Map and never delete keys to keep cache forever never deletes keys, so no expiration.

3. Final Answer:

   Use Map and setTimeout to delete the key after 5 seconds when setting cache -> Option A

4. Quick Check:

   Use setTimeout per key for expiration [OK]

Hint: Use setTimeout to delete each key after delay [OK]

Common Mistakes:

• Clearing whole cache instead of individual keys
• Expecting garbage collection to remove keys automatically
• Not deleting keys causes memory bloat