Passing data to workers in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What will this worker output?

Consider this Node.js worker code snippet. What will the worker print to the console?

Node.js

import { Worker, isMainThread, parentPort, workerData } from 'node:worker_threads';

if (isMainThread) {
  const worker = new Worker(new URL(import.meta.url));
  worker.postMessage({ greeting: 'hello' });
} else {
  parentPort.on('message', (msg) => {
    console.log(msg.greeting);
  });
}

A undefined

B hello

C ReferenceError

D No output

💡 Hint

Think about how the main thread sends data to the worker using postMessage and how the worker listens for messages.

The main thread sends an object with a greeting property to the worker using postMessage. The worker listens for 'message' events and logs the greeting property, so it prints 'hello'.

📝 Syntax

intermediate

Which option correctly passes initial data to a worker?

You want to pass initial data to a worker thread at creation. Which code snippet correctly does this?

A new Worker('worker.js', { data: { user: 'Alice' } })

B new Worker(new URL('worker.js', import.meta.url), { message: { user: 'Alice' } })

C new Worker('worker.js', { initialData: { user: 'Alice' } })

D new Worker(new URL('worker.js', import.meta.url), { workerData: { user: 'Alice' } })

💡 Hint

Check the official property name used to pass data at worker creation.

The correct option uses the 'workerData' property to pass initial data to the worker thread. Other options use invalid property names.

❓ state_output

advanced

What is the value of 'workerData' inside the worker?

Given this worker creation code, what will be the value of 'workerData' inside the worker thread?

Node.js

import { Worker, isMainThread, workerData } from 'node:worker_threads';

if (isMainThread) {
  new Worker(new URL(import.meta.url), { workerData: { count: 5, active: true } });
} else {
  console.log(workerData);
}

A {}

B undefined

C { count: 5, active: true }

D null

💡 Hint

Remember that 'workerData' contains the data passed at worker creation.

The workerData object inside the worker contains exactly what was passed in the main thread's Worker constructor.

🔧 Debug

advanced

Why does this worker not receive data?

This code intends to send data to the worker, but the worker never logs it. Why?

Node.js

import { Worker, isMainThread, parentPort, workerData } from 'node:worker_threads';

if (isMainThread) {
  const worker = new Worker(new URL(import.meta.url));
  worker.postMessage('data');
} else {
  console.log(workerData);
}

A workerData is undefined because data was sent via postMessage, not workerData option

B postMessage is not a function on worker

C parentPort is undefined in the worker

D The worker script URL is incorrect

💡 Hint

Check how data is accessed inside the worker and how it was sent.

workerData only contains data passed at creation. postMessage sends data asynchronously and must be received via parentPort.on('message').

🧠 Conceptual

expert

Which method correctly shares a large buffer efficiently between main and worker?

You want to share a large ArrayBuffer between the main thread and a worker without copying it. Which approach is correct?

A Pass the ArrayBuffer via workerData with a TransferList containing the buffer

B Send the ArrayBuffer via postMessage without a TransferList

C Serialize the ArrayBuffer to JSON and send as a string

D Write the buffer to a file and read it in the worker

💡 Hint

Think about zero-copy transfer of buffers in worker_threads.

Passing the buffer with a TransferList transfers ownership without copying, making it efficient. Sending without TransferList copies the data. JSON serialization is slow and lossy. File I/O is inefficient.

Practice

1. In Node.js, how do you pass initial data to a worker thread when creating it?

easy

A. By using the workerData option in the Worker constructor

B. By sending a message after the worker starts

C. By setting a global variable inside the worker file

D. By importing a module inside the worker

Solution

1. Step 1: Understand worker creation

   When creating a worker thread, you can pass data directly using the workerData option in the Worker constructor.

2. Step 2: Recognize data passing method

   This method allows the worker to access the data immediately via the imported workerData from 'worker_threads'.

3. Final Answer:

   By using the workerData option in the Worker constructor -> Option A

4. Quick Check:

   Initial data to worker = workerData option [OK]

Hint: Pass data at creation with workerData option [OK]

Common Mistakes:

• Trying to set global variables inside the worker
• Sending data only after worker starts
• Using imports to pass data

2. Which of the following is the correct syntax to create a worker and pass data to it?

easy

A. new Worker('worker.js', { workerData: { value: 10 } })

B. new Worker('worker.js', { message: { value: 10 } })

C. new Worker('worker.js', { initialData: { value: 10 } })

D. new Worker('worker.js', { data: { value: 10 } })

Solution

1. Step 1: Recall Worker constructor options

   The correct option to pass data when creating a worker is workerData.

2. Step 2: Match syntax with correct option

   Only new Worker('worker.js', { workerData: { value: 10 } }) uses workerData correctly; others use invalid keys.

3. Final Answer:

   new Worker('worker.js', { workerData: { value: 10 } }) -> Option A

4. Quick Check:

   Correct option key = workerData [OK]

Hint: Use workerData option exactly in Worker constructor [OK]

Common Mistakes:

• Using incorrect option names like data or initialData
• Confusing message passing with initial data passing
• Missing curly braces around data

3. Given this worker code snippet:

const { parentPort, workerData } = require('worker_threads');
parentPort.postMessage(workerData.num * 2);

And main thread code:

const { Worker } = require('worker_threads');
const worker = new Worker('./worker.js', { workerData: { num: 5 } });
worker.on('message', (result) => console.log(result));

What will be printed to the console?

medium

A. 5

B. 10

C. undefined

D. Error

Solution

1. Step 1: Understand workerData usage

   The worker receives workerData with { num: 5 } and multiplies num by 2.

2. Step 2: Trace message sent back

   The worker sends 5 * 2 = 10 back via parentPort.postMessage, which the main thread logs.

3. Final Answer:

   10 -> Option B

4. Quick Check:

   workerData.num * 2 = 10 [OK]

Hint: Multiply workerData.num by 2 and print [OK]

Common Mistakes:

• Confusing workerData with message event data
• Expecting original number instead of doubled
• Not listening to 'message' event

4. What is wrong with this code snippet for passing data to a worker?

const { Worker } = require('worker_threads');
const worker = new Worker('./worker.js', { workerData: 123 });
worker.on('message', (msg) => console.log(msg));

Assuming worker.js expects workerData to be an object with a value property.

medium

A. Worker file path is incorrect

B. Missing event listener for 'error'

C. postMessage is missing in main thread

D. workerData should be an object, not a number

Solution

1. Step 1: Check workerData type

   The worker expects workerData as an object with a value property, but a number 123 is passed.

2. Step 2: Identify mismatch impact

   This mismatch can cause errors or undefined behavior inside the worker when accessing workerData.value.

3. Final Answer:

   workerData should be an object, not a number -> Option D

4. Quick Check:

   workerData type must match expected structure [OK]

Hint: Pass workerData as expected object type [OK]

Common Mistakes:

• Passing primitive instead of object
• Ignoring workerData structure requirements
• Not handling errors from wrong data

5. You want to create a worker that receives an array of numbers as workerData.numbers, doubles each number, and sends back the new array. Which main thread code correctly passes data and listens for the result?

hard

A. const worker = new Worker('./worker.js', { workerData: [1,2,3] });
worker.on('message', (result) => console.log(result));

B. const worker = new Worker('./worker.js', { data: [1,2,3] });
worker.on('message', (result) => console.log(result));

C. const worker = new Worker('./worker.js', { workerData: { numbers: [1,2,3] } });
worker.on('message', (result) => console.log(result));

D. const worker = new Worker('./worker.js');
worker.postMessage([1,2,3]);
worker.on('message', (result) => console.log(result));

Solution

1. Step 1: Verify the correct workerData structure

   The worker accesses the array as workerData.numbers, so only code passing { workerData: { numbers: [1,2,3] } } works correctly.

2. Step 2: Confirm result handling

   The correct code includes worker.on('message', (result) => console.log(result)) to log the doubled array sent back by the worker.

3. Final Answer:

   const worker = new Worker('./worker.js', { workerData: { numbers: [1,2,3] } }); worker.on('message', (result) => console.log(result)); -> Option C

4. Quick Check:

   Pass array inside object via workerData and listen for message [OK]

Hint: Wrap array in object for workerData and listen to message [OK]

Common Mistakes:

• Passing array directly without object wrapper
• Using wrong option name like data
• Trying to send data after worker creation