Node.js
Esecuzione di file o comandi con Child Processes

Sintassi

• child_process.exec (comando [, opzioni] [, callback])
• child_process.execFile (file [, args] [, opzioni] [, callback])
• child_process.fork (modulePath [, args] [, options])
• child_process.spawn (command [, args] [, options])
• child_process.execFileSync (file [, args] [, opzioni])
• child_process.execSync (comando [, opzioni])
• child_process.spawnSync (command [, args] [, options])

Osservazioni

Creazione di un nuovo processo per eseguire un comando

Per generare un nuovo processo in cui è necessario un output non bufferizzato (ad esempio, processi a esecuzione prolungata che potrebbero stampare l'output in un determinato periodo di tempo anziché stampare ed uscire immediatamente), utilizzare child_process.spawn() .

Questo metodo genera un nuovo processo utilizzando un dato comando e un array di argomenti. Il valore restituito è un'istanza di ChildProcess , che a sua volta fornisce le proprietà stdout e stderr . Entrambi questi flussi sono istanze di stream.Readable . stream.Readable .

Il seguente codice equivale a utilizzare il comando ls -lh /usr .

const spawn = require('child_process').spawn;
const ls = spawn('ls', ['-lh', '/usr']);

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

ls.stderr.on('data', (data) => {
  console.log(`stderr: ${data}`);
});

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

Un altro comando di esempio:

zip -0vr "archive" ./image.png

Potrebbe essere scritto come:

spawn('zip', ['-0vr', '"archive"', './image.png']);

Creazione di una shell per eseguire un comando

Per eseguire un comando in una shell, in cui è richiesto l'output bufferizzato (ovvero non è un flusso), utilizzare child_process.exec . Ad esempio, se si desidera eseguire il comando cat *.js file | wc -l , senza opzioni, sarebbe simile a questo:

const exec = require('child_process').exec;
exec('cat *.js file | wc -l', (err, stdout, stderr) => {
  if (err) {
    console.error(`exec error: ${err}`);
    return;
  }

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

La funzione accetta fino a tre parametri:

child_process.exec(command[, options][, callback]);

Il parametro command è una stringa ed è obbligatorio, mentre l'oggetto options e callback sono entrambi facoltativi. Se non viene specificato alcun oggetto opzioni, exec userà quanto segue come predefinito:

{
  encoding: 'utf8',
  timeout: 0,
  maxBuffer: 200*1024,
  killSignal: 'SIGTERM',
  cwd: null,
  env: null
}

L'oggetto options supporta anche un parametro shell , che è di default /bin/sh su UNIX e cmd.exe su Windows, un'opzione uid per l'impostazione dell'identità utente del processo e un'opzione gid per l'identità di gruppo.

Il callback, che viene chiamato quando viene eseguito il comando, viene chiamato con i tre argomenti (err, stdout, stderr) . Se il comando viene eseguito correttamente, err sarà null , altrimenti sarà un'istanza di Error , dove err.code è il codice di uscita del processo e err.signal è il segnale che è stato inviato per terminarlo.

Gli argomenti stdout e stderr sono l'output del comando. Viene decodificato con la codifica specificata nell'oggetto options (default: string ), ma può essere altrimenti restituito come oggetto Buffer .

Esiste anche una versione sincrona di exec , che è execSync . La versione sincrona non ChildProcess una richiamata e restituirà stdout anziché un'istanza di ChildProcess . Se la versione sincrona incontra un errore, il programma verrà lanciato e interrotto. Sembra questo:

const execSync = require('child_process').execSync;
const stdout = execSync('cat *.js file | wc -l');
console.log(`stdout: ${stdout}`);

Generare un processo per eseguire un eseguibile

Se stai cercando di eseguire un file, come un eseguibile, usa child_process.execFile . Invece di child_process.exec una shell come child_process.exec , creerà direttamente un nuovo processo, che è leggermente più efficiente di un comando. La funzione può essere utilizzata in questo modo:

const execFile = require('child_process').execFile;
const child = execFile('node', ['--version'], (err, stdout, stderr) => {
  if (err) {
    throw err;
  }

  console.log(stdout);
});

A differenza di child_process.exec , questa funzione accetta fino a quattro parametri, in cui il secondo parametro è un array di argomenti che desideri fornire all'eseguibile:

child_process.execFile(file[, args][, options][, callback]);

Altrimenti, le opzioni e il formato di callback sono altrimenti identici a child_process.exec . Lo stesso vale per la versione sincrona della funzione:

const execFileSync = require('child_process').execFileSync;
const stdout = execFileSync('node', ['--version']);
console.log(stdout);