Node.js
Exécuter des fichiers ou des commandes avec des processus enfants

Syntaxe

• child_process.exec (commande [, options] [, callback])
• child_process.execFile (fichier [, args] [, options] [, callback])
• child_process.fork (modulePath [, args] [, options])
• child_process.spawn (commande [, args] [, options])
• child_process.execFileSync (fichier [, args] [, options])
• child_process.execSync (commande [, options])
• child_process.spawnSync (commande [, args] [, options])

Remarques

Création d'un nouveau processus pour exécuter une commande

Pour générer un nouveau processus dans lequel vous avez besoin d'une sortie sans tampon (par exemple, des processus de longue durée qui peuvent imprimer des résultats sur une child_process.spawn() période plutôt que d'imprimer et de quitter immédiatement), utilisez child_process.spawn() .

Cette méthode génère un nouveau processus en utilisant une commande donnée et un tableau d'arguments. La valeur de retour est une instance de ChildProcess , qui à son tour fournit les propriétés stdout et stderr . Ces deux flux sont des instances de stream.Readable .

Le code suivant est équivalent à l'utilisation de la commande 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 autre exemple de commande:

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

Peut-être écrit comme:

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

Création d'un shell pour exécuter une commande

Pour exécuter une commande dans un shell dans lequel vous avez besoin d'une sortie en mémoire tampon (c'est-à-dire que ce n'est pas un flux), utilisez child_process.exec . Par exemple, si vous souhaitez exécuter la commande cat *.js file | wc -l , sans options, cela ressemblerait à ceci:

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 fonction accepte jusqu'à trois paramètres:

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

Le paramètre de commande est une chaîne et est requis, tandis que l'objet options et le rappel sont tous deux facultatifs. Si aucun objet d'options n'est spécifié, alors exec utilise par défaut ce qui suit:

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

L'objet options prend également en charge un paramètre shell , par défaut /bin/sh sous UNIX et cmd.exe sous Windows, une option uid permettant de définir l'identité utilisateur du processus et une option gid pour l'identité du groupe.

Le rappel, appelé lors de l'exécution de la commande, est appelé avec les trois arguments (err, stdout, stderr) . Si la commande s'exécute avec succès, err sera null , sinon ce sera une instance de Error , err.code étant le code de sortie du processus et err.signal étant le signal envoyé pour le terminer.

Les arguments stdout et stderr sont la sortie de la commande. Il est décodé avec le codage spécifié dans l'objet options (default: string ), mais peut être renvoyé sous forme d'objet Buffer .

Il existe également une version synchrone de exec , qui est execSync . La version synchrone ne prend pas de rappel et renverra stdout au lieu d'une instance de ChildProcess . Si la version synchrone rencontre une erreur, elle lancera et arrêtera votre programme. Cela ressemble à ceci:

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

Création d'un processus pour exécuter un exécutable

Si vous souhaitez exécuter un fichier, tel qu'un exécutable, utilisez child_process.execFile . Au lieu de créer un shell comme pourrait le faire child_process.exec , cela créera directement un nouveau processus, ce qui est légèrement plus efficace que d'exécuter une commande. La fonction peut être utilisée comme ceci:

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

  console.log(stdout);
});

Contrairement à child_process.exec , cette fonction accepte jusqu'à quatre paramètres, le second paramètre étant un tableau d'arguments que vous souhaitez fournir à l'exécutable:

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

Sinon, les options et le format de rappel sont identiques à child_process.exec . Il en va de même pour la version synchrone de la fonction:

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