Come utilizzare il modulo Child Process in Node.js?

Il modulo “child\_process” in Node.js è utilizzato per creare nuovi processi. Questi processi figli possono comunicare con il processo principale attraverso un canale di comunicazione che consente loro di passare messaggi avanti e indietro.

Eccone un esempio di come utilizzare il modulo “child\_process” attraverso le sue funzioni `spawn()`, `exec()`, `execFile()` e `fork()`:

1. `spawn()`: questa funzione lancia un nuovo processo con un comando dato.

```
const { spawn } = require(‘child_process’);
const child = spawn(‘ls’, [‘-lh’, ‘/usr’]);

child.stdout.on(‘data’, (data) => { console.log(`stdout: ${data}`);
});

child.stderr.on(‘data’, (data) => { console.error(`stderr: ${data}`);
});

child.on(‘close’, (code) => { console.log(`processo figlio esce con codice ${code}`);
});
```

1. `exec()`: questa funzione funziona in modo simile a spawn(), ma accetta una stringa di comando invece di parametri separati. Questa funzione restituisce l’intero buffer di dati alla chiamata di callback.

```
const { exec } = require(‘child_process’);
exec(‘ls -lh /usr’, (error, stdout, stderr) => { if (error) { console.error(`exec error: ${error}`); return; }

console.log(`stdout: ${stdout}`); console.error(`stderr: ${stderr}`); }); ```

1. `execFile()`: questa funzione è simile a exec(), ma lancia direttamente il file di comando fornito che è facile da usare se si sta eseguendo solo un file eseguibile.

```
const { execFile } = require(‘child_process’);
const child = execFile(‘path-to-your-file’, [‘arg1’, ‘arg2’], (error, stdout, stderr) => { if (error) { throw error; } console.log(stdout);
});
```

1. `fork()`: questa funzione è una variante speciale della spawn() che crea un nuovo processo Node.js. Restituisce un oggetto con un canale di comunicazione integrato per passare i messaggi tra processo genitore e figlio.

```
const { fork } = require(‘child_process’);

const child = fork(‘./child.js’);

child.on(‘message’, (msg) => { console.log(‘Messaggio dal figlio’, msg);
});

child.send({ hello: ‘world’ });
```

Nell’ultimo esempio, il file child.js potrebbe somigliare a questo:

```
process.on(‘message’, (msg) => { console.log(‘Messaggio dal padre:’, msg);
});

let counter = 0;

setInterval(() => { process.send({ counter: counter++ });
}, 1000);
```

Ricorda che la creazione di processi figli è piuttosto costosa in termini di risorse, quindi l’uso improprio di queste API può portare a problemi di prestazioni.