Memory management best practices in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding Garbage Collection in Node.js

What happens when an object in Node.js is no longer referenced by any part of the program?

A The object is immediately deleted from memory by the programmer.

B The object remains in memory until the program ends.

C The object is moved to a special memory area for later use.

D The garbage collector automatically frees the memory used by the object.

💡 Hint

Think about how automatic memory cleanup works in modern programming environments.

Node.js uses a garbage collector that automatically frees memory for objects that are no longer referenced anywhere in the program. This helps prevent memory leaks without manual intervention.

❓ component_behavior

intermediate

Effect of Large Buffers on Memory

Consider this Node.js code snippet that creates a large buffer inside a function. What is the likely effect on memory after the function finishes if the buffer is not returned or stored elsewhere?

Node.js

function createBuffer() {
  const buf = Buffer.alloc(10 * 1024 * 1024); // 10MB buffer
  // do something with buf
}
createBuffer();

A The buffer is eligible for garbage collection after the function ends because it is not referenced.

B The buffer is freed only when the program exits.

C The 10MB buffer remains in memory indefinitely, causing a memory leak.

D The buffer is copied to a global variable automatically.

💡 Hint

Think about what happens to local variables after a function finishes if they are not saved.

Since the buffer is a local variable and not referenced outside the function, once the function ends, the buffer becomes unreachable. The garbage collector will then free its memory.

🔧 Debug

advanced

Identifying Memory Leak Cause

Which option best explains why this Node.js code causes a memory leak?

Node.js

const cache = {};
function addToCache(key, value) {
  cache[key] = value;
}

setInterval(() => {
  addToCache(Date.now(), new Array(1000000).fill('*'));
}, 1000);

A The setInterval function is not cleared, causing multiple timers to run.

B The cache object keeps growing without removing old entries, preventing garbage collection.

C The array is too large to be stored in memory, causing immediate crash.

D The Date.now() function returns the same value every second, overwriting cache keys.

💡 Hint

Think about what happens when you keep adding data to an object without removing anything.

The cache object grows indefinitely because old entries are never removed. This prevents the garbage collector from freeing memory, causing a memory leak.

📝 Syntax

advanced

Correct Use of Weak References to Avoid Memory Leaks

Which code snippet correctly uses a WeakMap to store objects without preventing their garbage collection?

A

const wm = new WeakMap();
const obj = {};
wm.set(obj, 'value');

B

const wm = new WeakMap();
const obj = {};
wm.set('key', obj);

C

const wm = new WeakMap();
const obj = {};
wm.set({}, 'value');

D

const wm = new WeakMap();
wm.set('key', 'value');

💡 Hint

Remember that WeakMap keys must be objects, not strings or primitives.

WeakMap keys must be objects. Option A uses an object as the key and a string as the value, which is correct. Option A and D use strings as keys, which is invalid. Option A uses a new object literal as key but does not keep a reference, so it is immediately lost and not useful.

❓ state_output

expert

Memory Usage After Manual Buffer Nullification

What is the expected behavior of the memory usage after running this Node.js code?

Node.js

let bigBuffer = Buffer.alloc(50 * 1024 * 1024); // 50MB buffer
console.log(process.memoryUsage().heapUsed);
bigBuffer = null;
setTimeout(() => {
  console.log(process.memoryUsage().heapUsed);
}, 1000);

A The program will crash due to freeing memory manually.

B The second memory usage log will show a significantly lower heapUsed value because the buffer is freed.

C The second memory usage log will be the same or slightly higher because garbage collection may not have run yet.

D The buffer remains in memory because setting to null does not affect references.

💡 Hint

Think about when garbage collection runs and how memory usage is reported.

Setting the buffer variable to null removes the reference, but garbage collection runs asynchronously. The memory may not be freed immediately, so the second log may show similar or slightly higher heap usage.