Common memory leak patterns in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Identifying memory leaks from event listeners

In Node.js, which of the following patterns is most likely to cause a memory leak related to event listeners?

A Adding event listeners inside a function without removing them when no longer needed

B Using async/await to handle asynchronous code

C Declaring variables with const instead of let

D Using setTimeout with a delay of zero milliseconds

💡 Hint

Think about what happens if event listeners keep accumulating over time.

Adding event listeners repeatedly without removing them causes the listeners to accumulate in memory, leading to leaks.

❓ component_behavior

intermediate

Effect of global variables on memory usage

What happens to memory usage in a Node.js application if large objects are stored in global variables and never cleared?

A Memory usage fluctuates randomly without any pattern

B Memory usage stays constant because global variables are optimized by the engine

C Memory usage increases over time because the objects remain referenced globally

D Memory usage decreases automatically as Node.js garbage collects global variables

💡 Hint

Consider how garbage collection works with references.

Objects referenced by global variables are never freed, causing memory to grow as more objects accumulate.

🔧 Debug

advanced

Diagnosing memory leak from closures

Examine the following code snippet. What is the main cause of the memory leak?

Node.js

function createHandler() {
  const largeData = new Array(1000000).fill('data');
  return function handler() {
    console.log(largeData[0]);
  };
}

const handlers = [];
for (let i = 0; i < 1000; i++) {
  handlers.push(createHandler());
}

A The closure keeps a reference to largeData, preventing it from being garbage collected

B The array largeData is too large to be stored in memory

C The console.log statement causes memory to leak

D The for loop runs too many times causing a stack overflow

💡 Hint

Think about what the returned function remembers from its creation context.

The returned handler function forms a closure that holds onto the largeData array, so none of these arrays can be freed while handlers exist.

📝 Syntax

advanced

Identifying incorrect use of timers causing leaks

Which option shows a timer usage pattern that will cause a memory leak in Node.js?

A setTimeout(() => { /* some code */ }, 1000); // runs once

B setInterval(() => { /* some code */ }, 1000); // never cleared

C clearInterval(timerId); // clears interval properly

D setImmediate(() => { /* some code */ }); // runs once immediately

💡 Hint

Consider what happens if intervals are never stopped.

Using setInterval without clearing it causes the callback to run forever, potentially holding references and leaking memory.

❓ state_output

expert

Memory usage after removing references

Given the following code, what will be the approximate memory usage behavior after running it?

Node.js

let cache = {};

function addToCache(key) {
  cache[key] = new Array(1000000).fill('x');
}

for (let i = 0; i < 10; i++) {
  addToCache(i);
}

// Now clear cache
cache = null;

// What happens next?

A Memory usage will cause a crash immediately

B Memory usage will stay high because the arrays are still referenced elsewhere

C Memory usage will increase because setting cache to null creates new objects

D Memory usage will drop because cache is set to null and objects become unreachable

💡 Hint

Think about what happens when references are removed.

Setting cache to null removes references to the large arrays, allowing garbage collection to free memory.

Practice

1. Which of the following is a common cause of memory leaks in Node.js applications?

easy

A. Keeping references to objects that are no longer needed

B. Using asynchronous functions

C. Writing synchronous code

D. Using the latest Node.js version

Solution

1. Step 1: Understand what causes memory leaks

   Memory leaks happen when your program holds onto data it no longer needs, preventing the system from freeing memory.

2. Step 2: Identify the correct cause among options

   Keeping references to unused objects prevents garbage collection, causing leaks. Other options do not inherently cause leaks.

3. Final Answer:

   Keeping references to objects that are no longer needed -> Option A

4. Quick Check:

   Memory leaks = unused references [OK]

Hint: Memory leaks happen when unused data is still referenced [OK]

Common Mistakes:

• Thinking async code always causes leaks
• Confusing synchronous code with leaks
• Assuming Node.js version causes leaks

2. Which syntax correctly removes an event listener in Node.js to help prevent memory leaks?

easy

A. emitter.deleteListener('event', callback);

B. emitter.off('event');

C. emitter.remove('event', callback);

D. emitter.removeListener('event', callback);

Solution

1. Step 1: Recall Node.js event listener removal syntax

   The correct method to remove a specific listener is removeListener(event, callback).

2. Step 2: Check each option's validity

   emitter.removeListener('event', callback); uses the correct method. emitter.off('event'); removes all listeners but omits the specific callback. Options A and C are not valid methods.

3. Final Answer:

   emitter.removeListener('event', callback); -> Option D

4. Quick Check:

   Correct method = removeListener(event, callback) [OK]

Hint: Use removeListener with event and callback to remove listeners [OK]

Common Mistakes:

• Using emitter.off without callback
• Using non-existent methods like remove or deleteListener
• Omitting the callback function

3. Consider this code snippet:

const cache = {};
function addToCache(key, value) {
  cache[key] = value;
}
addToCache('user1', {name: 'Alice'});
addToCache('user2', {name: 'Bob'});
console.log(Object.keys(cache).length);

What will be the output and what memory issue might this cause if keys are never removed?

medium

A. 0; No memory leak because cache is empty

B. 2; Memory leak due to unbounded cache growth

C. Error; Syntax error in code

D. Undefined; cache is not defined

Solution

1. Step 1: Analyze the code output

   The cache object stores two keys: 'user1' and 'user2'. Object.keys(cache).length returns 2.

2. Step 2: Identify memory issue

   Since keys are never removed, cache grows indefinitely, causing a memory leak.

3. Final Answer:

   2; Memory leak due to unbounded cache growth -> Option B

4. Quick Check:

   Cache size = 2, leak if keys never removed [OK]

Hint: Uncleared caches cause leaks; count keys to check size [OK]

Common Mistakes:

• Thinking cache is empty initially
• Assuming syntax error without checking code
• Confusing undefined with empty object

4. You have this code causing a memory leak:

const listeners = [];
function addListener(emitter, callback) {
  emitter.on('data', callback);
  listeners.push({emitter, callback});
}
// Later you forget to remove listeners

What is the best fix to prevent the leak?

medium

A. Remove listeners with emitter.removeListener and clear the listeners array

B. Do nothing; Node.js cleans up automatically

C. Replace emitter.on with emitter.once

D. Use global variables instead of arrays

Solution

1. Step 1: Identify cause of leak

   Listeners are added and stored in an array but never removed, causing memory to stay used.

2. Step 2: Apply fix to remove listeners and clear references

   Use emitter.removeListener with stored callbacks and clear the listeners array to free memory.

3. Final Answer:

   Remove listeners with emitter.removeListener and clear the listeners array -> Option A

4. Quick Check:

   Remove listeners + clear refs = fix leak [OK]

Hint: Always remove event listeners and clear stored references [OK]

Common Mistakes:

• Assuming Node.js auto-cleans listeners
• Using emitter.once without removing listeners
• Using global variables increases leaks

5. You have a Node.js app caching user sessions in a global object. Over time, memory usage grows unexpectedly. Which combined approach best prevents this memory leak?

hard

A. Use global variables for caching without cleanup

B. Store all sessions indefinitely to avoid losing data

C. Implement session expiration and remove expired sessions from cache regularly

D. Avoid using any caching to prevent leaks

Solution

1. Step 1: Understand the problem with indefinite caching

   Storing sessions forever causes the cache to grow without limit, leading to memory leaks.

2. Step 2: Apply session expiration and cleanup

   Removing expired sessions regularly frees memory and prevents leaks while keeping useful data.

3. Final Answer:

   Implement session expiration and remove expired sessions from cache regularly -> Option C

4. Quick Check:

   Expire and clean cache to prevent leaks [OK]

Hint: Expire and clear cached data regularly to avoid leaks [OK]

Common Mistakes:

• Keeping all data forever causes leaks
• Avoiding caching is not practical
• Using globals without cleanup worsens leaks