Watching files for changes in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when you use fs.watch on a file?

Consider this Node.js code snippet using fs.watch to watch a file for changes. What will the output be when the file is modified?

Node.js

import { watch } from 'fs';

watch('example.txt', (eventType, filename) => {
  if (filename) {
    console.log(`${filename} file Changed: ${eventType}`);
  }
});

A Logs 'example.txt file Changed: change' each time the file is modified.

B Logs 'example.txt file Changed: rename' when the file content changes.

C Throws an error because fs.watch cannot watch files, only directories.

D Logs nothing because the callback is never called on file changes.

💡 Hint

Think about what eventType values fs.watch emits on file changes.

The fs.watch function watches the file and triggers the callback with eventType 'change' when the file content changes. It does not throw an error and does not ignore file changes.

📝 Syntax

intermediate

Identify the syntax error in this fs.watch usage

Which option contains the correct syntax to watch a file named 'log.txt' and log changes?

Node.js

import { watch } from 'fs';

watch('log.txt', (event, file) => {
  console.log(`${file} was ${event}`);
});

A watch('log.txt', (event, file) => { console.log(`${file} was ${event}`) };

B watch('log.txt', (event, file) => { console.log(`${file} was ${event}`) });

C watch('log.txt', (event, file) => console.log(`${file} was ${event}`));

D watch('log.txt', (event, file) => { console.log(`${file} was ${event}`); });

💡 Hint

Check for missing semicolons and braces in arrow functions.

Option D correctly uses braces and a semicolon inside the arrow function body. Option D misses the closing parenthesis and semicolon, causing a syntax error.

🔧 Debug

advanced

Why does this fs.watch code miss some file changes?

This code watches 'data.json' but sometimes misses changes. Why?

Node.js

import { watch } from 'fs';

watch('data.json', (eventType) => {
  if (eventType === 'change') {
    console.log('File changed');
  }
});

A Because fs.watch is not 100% reliable and may miss rapid changes.

B Because the callback does not check the filename parameter.

C Because the watch function requires a third argument for recursive watching.

D Because the eventType should be compared to 'rename' instead of 'change'.

💡 Hint

Consider the limitations of fs.watch on different platforms.

fs.watch can miss some changes especially if they happen quickly or in bursts. This is a known limitation of the underlying OS file watching APIs.

❓ state_output

advanced

What is the output count of this watcher after multiple changes?

Given this code watching 'notes.txt', if the file is changed 3 times quickly, how many times will the console log 'notes.txt changed'?

Node.js

import { watch } from 'fs';

let count = 0;
watch('notes.txt', (eventType, filename) => {
  if (eventType === 'change') {
    count++;
    console.log(`${filename} changed`);
  }
});

A Exactly 3 times, once per change.

B At least 1 time, but possibly fewer than 3 due to event coalescing.

C 0 times, because the callback is not triggered for rapid changes.

D More than 3 times, because each change triggers multiple events.

💡 Hint

Think about how fs.watch batches or coalesces events on some systems.

fs.watch may combine multiple rapid changes into fewer events, so the callback might be called fewer than the number of actual changes.

🧠 Conceptual

expert

Which statement about fs.watch and fs.watchFile is true?

Choose the correct statement about the differences between fs.watch and fs.watchFile in Node.js.

A Both <code>fs.watch</code> and <code>fs.watchFile</code> use the same underlying mechanism and have identical performance.

B <code>fs.watchFile</code> uses OS-level events and is more efficient than <code>fs.watch</code>.

C <code>fs.watch</code> uses OS-level events and is more efficient but less consistent across platforms than <code>fs.watchFile</code>.

D <code>fs.watch</code> polls the file system periodically, while <code>fs.watchFile</code> uses native OS events.

💡 Hint

Consider how each function detects changes under the hood.

fs.watch relies on native OS events, making it more efficient but sometimes inconsistent. fs.watchFile uses polling, which is consistent but less efficient.