fork for Node.js child processes in Node.js - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the correct method to create a child process.

Node.js

const { [1] } = require('child_process');

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

AexecFile

Bexec

Cfork

Dspawn

Attempts:

3 left

💡 Hint

Common Mistakes

Choosing spawn or exec which are for other process types.

The fork method is used to create a new Node.js process that can communicate with the parent process.

2fill in blank

medium

Complete the code to fork a child process running the script 'worker.js'.

Node.js

const child = fork('[1]');

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

A'worker.js'

B'server.js'

C'child.js'

D'index.js'

Attempts:

3 left

💡 Hint

Common Mistakes

Using a wrong file name that does not exist or is not intended.

The fork method takes the path to the JavaScript file to run in the child process. Here, it is worker.js.

3fill in blank

hard

Fix the error in sending a message from the parent to the child process.

Node.js

child.[1]({ type: 'start' });

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

Aemit

BpostMessage

Cwrite

Dsend

Attempts:

3 left

💡 Hint

Common Mistakes

Using emit which is for events, not IPC messages.

The send method is used to send messages to a child process created with fork.

4fill in blank

hard

Fill both blanks to listen for messages from the child process and log them.

Node.js

child.on('[1]', ([2]) => {
  console.log('Message from child:', [2]);
});

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

Amessage

Bmsg

Cdata

Dsend

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong event names like send or data.

The event to listen for messages is message. The callback receives the message, here named msg.

5fill in blank

hard

Fill all three blanks to create a child process, send a message, and handle its exit.

Node.js

const child = [1]('task.js');
child.[2]({ action: 'run' });
child.on('[3]', () => {
  console.log('Child process exited');
});

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

Afork

Bsend

Cexit

Dspawn

Attempts:

3 left

💡 Hint

Common Mistakes

Using spawn instead of fork.

Using emit instead of send.

Listening for wrong events like close instead of exit.

Use fork to create the child, send to communicate, and listen for the exit event to know when it ends.

Practice

1. What does the fork method in Node.js do?

easy

A. It merges two running processes into one.

B. It pauses the current process for a set time.

C. It creates a new Node.js process to run a separate script.

D. It stops the current process immediately.

Solution

1. Step 1: Understand the purpose of fork

   The fork method is used to create a new child process that runs a separate Node.js script independently.

2. Step 2: Compare options with the definition

   Only It creates a new Node.js process to run a separate script. correctly describes this behavior. Other options describe unrelated actions like pausing, merging, or stopping processes.

3. Final Answer:

   It creates a new Node.js process to run a separate script. -> Option C

4. Quick Check:

   fork creates child process = C [OK]

Hint: Remember: fork means start a new Node.js process [OK]

Common Mistakes:

• Thinking fork pauses or merges processes
• Confusing fork with setTimeout or kill
• Assuming fork runs code in the same process

2. Which of the following is the correct way to import and use fork from the child_process module in Node.js?

easy

A. const fork = require('child_process').fork();

B. const { fork } = require('child_process');

C. import fork from 'child_process';

D. const fork = require('child_process').Fork;

Solution

1. Step 1: Recall correct import syntax for fork

   In Node.js CommonJS, fork is a named export from child_process, so we use destructuring: const { fork } = require('child_process');

2. Step 2: Analyze each option

   const fork = require('child_process').fork(); calls fork() immediately, which is incorrect. import fork from 'child_process'; uses ES module syntax without proper setup. const fork = require('child_process').fork; assigns the function but misses destructuring. const { fork } = require('child_process'); is correct.

3. Final Answer:

   const { fork } = require('child_process'); -> Option B

4. Quick Check:

   Destructure fork from child_process = A [OK]

Hint: Use curly braces to import fork: const { fork } = require(...) [OK]

Common Mistakes:

• Calling fork() during import
• Using ES module import without config
• Not destructuring fork from module

3. What will be the output of this Node.js code snippet?

const { fork } = require('child_process');
const child = fork('child.js');
child.on('message', (msg) => {
  console.log('Parent received:', msg);
});
child.send('Hello Child');

// child.js content:
// process.on('message', (msg) => {
//   process.send(msg + ' from Child');
// });

medium

A. No output because child.js is missing

B. Parent received: Hello Child

C. Error: child.send is not a function

D. Parent received: Hello Child from Child

Solution

1. Step 1: Understand message passing between parent and child

   The parent sends 'Hello Child' to the child process. The child listens for messages and replies by appending ' from Child'.

2. Step 2: Trace the output

   The parent listens for messages from the child and logs them. So it logs: 'Parent received: Hello Child from Child'.

3. Final Answer:

   Parent received: Hello Child from Child -> Option D

4. Quick Check:

   Message sent and replied correctly = D [OK]

Hint: Child replies with modified message; parent logs it [OK]

Common Mistakes:

• Assuming child.send is undefined
• Ignoring message event listeners
• Thinking output is only 'Hello Child'

4. Identify the error in this code using fork and how to fix it:

const { fork } = require('child_process');
const child = fork('child.js');
child.send('start');
child.on('message', (msg) => {
  console.log(msg);
});

Assuming child.js does not listen for messages.

medium

A. Error because child.js must listen for messages before parent sends.

B. No error; code works fine.

C. Error because fork requires a callback function.

D. Error because child.send is not a function.

Solution

1. Step 1: Check message handling in child.js

   If child.js does not listen for messages, sending messages from parent has no effect and may cause unexpected behavior.

2. Step 2: Fix by adding message listener in child.js

   Child script should have process.on('message', (msg) => { ... }) to handle incoming messages properly.

3. Final Answer:

   Error because child.js must listen for messages before parent sends. -> Option A

4. Quick Check:

   Child must listen for messages = A [OK]

Hint: Child must handle messages before parent sends [OK]

Common Mistakes:

• Assuming fork needs callback
• Thinking child.send is undefined
• Ignoring child.js message listener

5. You want to run two separate scripts worker1.js and worker2.js in parallel using fork. You also want to collect their results and print "All done" only after both finish. Which approach correctly achieves this?

hard

A. Fork both scripts, listen for 'exit' events on both, then print after both exit.

B. Fork one script, then fork the second inside the first child's 'exit' event.

C. Fork both scripts and print "All done" immediately after forking.

D. Use exec instead of fork to run scripts sequentially.

Solution

1. Step 1: Understand parallel execution with fork

   Forking both scripts starts them in parallel. To know when both finish, listen for their 'exit' events.

2. Step 2: Wait for both exit events before printing

   Track both exits with counters or flags, then print "All done" only after both have exited.

3. Final Answer:

   Fork both scripts, listen for 'exit' events on both, then print after both exit. -> Option A

4. Quick Check:

   Wait for both exits before printing = B [OK]

Hint: Use 'exit' events on both children to sync completion [OK]

Common Mistakes:

• Starting second child inside first child's exit
• Printing before children finish
• Using exec for parallel child processes