spawn for streaming processes in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this Node.js spawn code?

Consider this code snippet using spawn from child_process. What will be printed to the console?

Node.js

import { spawn } from 'child_process';

const ls = spawn('ls', ['-l']);

ls.stdout.on('data', (data) => {
  console.log(`Output chunk: ${data.toString()}`);
});

ls.stderr.on('data', (data) => {
  console.error(`Error chunk: ${data.toString()}`);
});

ls.on('close', (code) => {
  console.log(`Process exited with code ${code}`);
});

A The console prints the directory listing in chunks, then 'Process exited with code 0'.

B The console prints nothing because spawn does not emit data events.

C The console prints an error because 'ls' is not a valid command in Node.js.

D The console prints 'Process exited with code 1' immediately without output.

💡 Hint

Think about how spawn streams output and how events are emitted.

The spawn function runs the 'ls -l' command and streams its output. The 'data' event on stdout emits chunks of the directory listing. When the process ends, the 'close' event fires with exit code 0 indicating success.

📝 Syntax

intermediate

Which option correctly spawns a process to stream output line-by-line?

You want to spawn a process and handle its output line-by-line as it streams. Which code snippet correctly sets this up?

A

const proc = spawn('ping', ['-c', '4', 'google.com']);
proc.stdout.on('data', (line) => {
  console.log(line);
});

B

const proc = spawn('ping', ['-c', '4', 'google.com']);
proc.stdout.on('line', (line) => {
  console.log(line);
});

C

const proc = spawn('ping', ['-c', '4', 'google.com']);
proc.stdout.on('data', (data) => {
  data.toString().split('\n').forEach(line => console.log(line));
});

D

const proc = spawn('ping', ['-c', '4', 'google.com']);
proc.stdout.on('chunk', (chunk) => {
  console.log(chunk.toString());
});

💡 Hint

Remember that 'data' events emit buffers, not lines.

The 'data' event emits chunks of data, which may contain multiple lines or partial lines. Splitting the chunk by newline characters lets you handle output line-by-line. There is no 'line' or 'chunk' event on stdout.

🔧 Debug

advanced

Why does this spawn code never print output?

This code spawns a process but never prints any output. What is the cause?

Node.js

import { spawn } from 'child_process';

const proc = spawn('node', ['-e', "console.log('hello')"]);

proc.stdout.on('data', (data) => {
  console.log(`Output: ${data}`);
});

A The process exits before the event listener is attached, missing the output.

B The code is correct and will print 'Output: hello' as expected.

C The output is sent to stderr, not stdout, so 'data' event on stdout never fires.

D The process output is buffered and not flushed, so no 'data' event fires.

💡 Hint

Check if the output is sent to stdout or stderr and if listeners are attached properly.

The spawned node process runs a script that prints 'hello' to stdout. The listener on stdout 'data' event will receive this output and print it. The code works correctly and prints 'Output: hello'.

❓ state_output

advanced

What is the value of variable 'output' after this spawn code runs?

Given this code, what will be the final value of the 'output' variable after the process closes?

Node.js

import { spawn } from 'child_process';

let output = '';
const proc = spawn('echo', ['Hello World']);

proc.stdout.on('data', (data) => {
  output += data.toString();
});

proc.on('close', () => {
  console.log('Process done');
});

A 'Hello World\n'

B 'Hello World'

C '' (empty string)

D undefined

💡 Hint

Remember what the echo command outputs including line breaks.

The echo command outputs 'Hello World' followed by a newline character. The data event appends this string including the newline to 'output'.

🧠 Conceptual

expert

Which option best explains why spawn is preferred over exec for streaming large outputs?

Why do developers often choose spawn instead of exec when they want to process large output streams from child processes?

A spawn automatically parses output into JSON, while exec returns raw strings.

B spawn can only run shell commands, while exec can run any executable.

C spawn runs processes asynchronously, but exec runs them synchronously blocking the event loop.

D spawn streams output data in chunks, avoiding buffer size limits, while exec buffers all output in memory before returning.

💡 Hint

Think about memory usage and how output is handled in both methods.

spawn returns streams for stdout and stderr, allowing processing of output as it arrives. exec buffers the entire output in memory, which can cause issues with large outputs.