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.