In Node.js, file watching can be achieved using the built-in fs module. However, in some cases, you may need more control or flexibility, such as tracking changes in a large number of files or performing additional operations when a file changes. In such scenarios, using child processes can provide a more scalable solution.

Prerequisites

To follow along with this demonstration, you need to have Node.js installed on your system.

Overview

We will create a file watcher that monitors a specific directory for any changes in the files using child processes. Whenever a file is modified, we will spawn a child process to handle the change. This approach allows us to distribute the file processing workload across multiple child processes, resulting in better performance.

Implementation

Step 1: Setting up the project

Create a new directory for your project and navigate to it in your terminal. Initialize a new Node.js project by running the following command:

$ npm init -y

Step 2: Installing dependencies

Install the required dependencies by running the following command in your project’s directory:

$ npm install chokidar

Step 3: Writing the code

Create a new file called fileWatcher.js and add the following code:

const chokidar = require('chokidar');
const { spawn } = require('child_process');

const watchedPath = '/path/to/directory'; // Replace with the path to the directory you want to watch

const watcher = chokidar.watch(watchedPath, { ignored: /^\./, persistent: true });

watcher.on('change', (filePath) => {
  console.log(`File modified: ${filePath}`);

  const childProcess = spawn('node', ['childProcessHandler.js', filePath]);

  childProcess.on('close', (code) => {
    console.log(`Child process exited with code ${code}`);
  });
});

console.log(`Watching directory: ${watchedPath}`);

Step 4: Handling the file change in a child process

Create a new file called childProcessHandler.js and add the following code:

const filePath = process.argv[2];

console.log(`Processing file: ${filePath}`);

// Your custom file handling logic goes here

// For example, you can read the contents of the file using the fs module
const fs = require('fs');
fs.readFile(filePath, 'utf8', (err, data) => {
  if (err) {
    console.error(err);
    return;
  }

  console.log(`File contents: \n${data}`);
});

Running the file watcher

To start the file watcher, run the following command in your terminal:

$ node fileWatcher.js

Replace /path/to/directory in fileWatcher.js with the actual path to the directory you want to watch. The watcher will monitor the specified directory for any file changes.

Conclusion

In this tutorial, we learned how to implement a file watcher using child processes in Node.js. By using child processes, we can distribute the file processing workload across multiple processes, leading to better performance and scalability. Whether you need to monitor a directory for changes or perform custom operations when files are modified, this approach can be a powerful solution.