Memory management best practices in Node.js - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a new buffer of 10 bytes in Node.js.

Node.js

const buffer = Buffer.[1](10);

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

Amake

Bcreate

Cnew

Dalloc

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'new Buffer()' which is deprecated and unsafe.

Trying to use 'Buffer.create()' which does not exist.

The Buffer.alloc(size) method creates a new buffer of the specified size filled with zeros. This is the safe way to allocate memory in Node.js.

2fill in blank

medium

Complete the code to free up memory by clearing a large object reference.

Node.js

let largeObject = { data: 'some large data' };
// When done, set to [1] to help garbage collection

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

Anull

B0

Cundefined

Dfalse

Attempts:

3 left

💡 Hint

Common Mistakes

Setting the variable to 0 or false does not remove the object reference.

Setting to undefined is possible but null is clearer for intent.

Setting a variable to null removes the reference to the object, allowing Node.js garbage collector to reclaim memory.

3fill in blank

hard

Fix the error in the code to avoid memory leaks by removing event listeners properly.

Node.js

const EventEmitter = require('events');
const emitter = new EventEmitter();

function onData() {
  console.log('Data received');
}
emitter.on('data', onData);

// To prevent leaks, remove listener with emitter.[1]('data', onData);

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

AremoveListener

BdeleteListener

Coff

DremoveEvent

Attempts:

3 left

💡 Hint

Common Mistakes

Using removeEvent which does not exist.

Using deleteListener which is not a method.

The off method is the modern way to remove event listeners in Node.js, preventing memory leaks.

4fill in blank

hard

Fill both blanks to create a WeakMap and add an object key with a value.

Node.js

const [1] = new [2]();
const objKey = {};
weakMap.set(objKey, 'value');

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

AweakMap

BWeakMap

CMap

Dweakmap

Attempts:

3 left

💡 Hint

Common Mistakes

Using Map instead of WeakMap which does not allow garbage collection of keys.

Using lowercase weakmap which is not a valid constructor.

A WeakMap allows keys to be garbage collected if there are no other references. Naming the variable weakMap is a common convention.

5fill in blank

hard

Fill all three blanks to create a memory-efficient cache using a WeakMap and add an entry.

Node.js

const [1] = new [2]();
const user = { id: 1 };
[3].set(user, { name: 'Alice' });

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

Acache

BWeakMap

DMap

Attempts:

3 left

💡 Hint

Common Mistakes

Using Map instead of WeakMap which keeps strong references.

Using inconsistent variable names.

Using a WeakMap named cache helps store data linked to objects without preventing garbage collection.

Practice

1. Which of the following is a good practice to help Node.js manage memory efficiently?

easy

A. Use streams to process large data instead of loading it all at once

B. Keep all data in global variables for easy access

C. Avoid using asynchronous functions to reduce complexity

D. Never clear timers or intervals once set

Solution

1. Step 1: Understand memory usage with large data

   Loading large data all at once uses a lot of memory. Streams process data in small chunks, saving memory.

2. Step 2: Evaluate options for memory efficiency

   Using global variables or never clearing timers can cause memory leaks. Avoiding async functions doesn't help memory.

3. Final Answer:

   Use streams to process large data instead of loading it all at once -> Option A

4. Quick Check:

   Streams save memory by chunking data [OK]

Hint: Streams handle big data efficiently, avoid globals [OK]

Common Mistakes:

• Thinking global variables are memory efficient
• Ignoring the need to clear timers
• Believing async functions cause memory leaks

2. Which syntax correctly clears a timeout timer in Node.js to prevent memory leaks?

easy

A. clearTimeout(timerId);

B. clearInterval(timerId);

C. stopTimer(timerId);

D. removeTimer(timerId);

Solution

1. Step 1: Identify the correct function to clear a timeout

   Node.js uses clearTimeout() to stop timers set by setTimeout().

2. Step 2: Match function to timer type

   clearInterval() clears intervals, not timeouts. stopTimer() and removeTimer() are invalid.

3. Final Answer:

   clearTimeout(timerId); -> Option A

4. Quick Check:

   clearTimeout() stops setTimeout timers [OK]

Hint: Use clearTimeout for setTimeout timers [OK]

Common Mistakes:

• Confusing clearTimeout with clearInterval
• Using non-existent functions like stopTimer
• Not clearing timers at all

3. What will be the output of the following code snippet regarding memory usage?

const data = [];
setInterval(() => {
  data.push(new Array(1000000).fill('x'));
  console.log('Data length:', data.length);
}, 1000);

medium

A. Data length stays at 1, memory usage is stable

B. Data length increases indefinitely, causing memory to grow

C. Throws an error after first interval

D. Data length resets to zero every second

Solution

1. Step 1: Analyze the setInterval behavior

   Every second, a large array is added to the data array, increasing its size.

2. Step 2: Understand memory impact

   Since data keeps growing without clearing, memory usage grows indefinitely, risking leaks.

3. Final Answer:

   Data length increases indefinitely, causing memory to grow -> Option B

4. Quick Check:

   Growing arrays without cleanup increase memory [OK]

Hint: Adding large arrays repeatedly grows memory [OK]

Common Mistakes:

• Assuming data length resets automatically
• Expecting an error without memory limits
• Thinking memory stays stable without cleanup

4. Identify the memory leak issue in this Node.js code:

let cache = {};
function addToCache(key, value) {
  cache[key] = value;
}
setInterval(() => {
  addToCache(Date.now(), new Array(1000000).fill('leak'));
}, 1000);

medium

A. Arrays are too small to cause memory issues

B. Using Date.now() as key causes syntax error

C. The cache object grows indefinitely without cleanup

D. setInterval is cleared automatically, no leak

Solution

1. Step 1: Examine cache growth

   Each second, a new large array is added with a unique key, so cache size grows endlessly.

2. Step 2: Understand memory leak cause

   Without removing old entries, memory usage increases causing a leak.

3. Final Answer:

   The cache object grows indefinitely without cleanup -> Option C

4. Quick Check:

   Uncleared caches cause memory leaks [OK]

Hint: Uncleared caches with growing keys leak memory [OK]

Common Mistakes:

• Thinking Date.now() causes syntax errors
• Assuming setInterval clears itself
• Underestimating array size impact

5. You have a Node.js app that processes large files. Which combined approach best prevents memory leaks and high memory use?

hard

A. Process files in memory, use setInterval without clearing, and avoid streams

B. Load entire files into memory, keep global caches, and never clear timers

C. Use synchronous file reads, keep data in global variables, and clear timers

D. Use streams to process files, clear timers after use, and avoid global caches

Solution

1. Step 1: Choose memory-efficient file processing

   Streams process large files in chunks, reducing memory use compared to loading whole files.

2. Step 2: Manage timers and caches properly

   Clearing timers prevents leaks. Avoiding global caches stops memory from growing endlessly.

3. Final Answer:

   Use streams to process files, clear timers after use, and avoid global caches -> Option D

4. Quick Check:

   Streams + clear timers + no globals = best memory practice [OK]

Hint: Combine streams, clear timers, avoid globals for best memory [OK]

Common Mistakes:

• Loading full files into memory
• Not clearing timers causing leaks
• Using global caches without cleanup