Node.js
Ausführen von Dateien oder Befehlen mit untergeordneten Prozessen

Syntax

• child_process.exec (Befehl [, Optionen] [, Rückruf])
• child_process.execFile (datei [, args] [, options] [, callback])
• child_process.fork (modulePath [, args] [, options])
• child_process.spawn (Befehl [, Argumente] [, Optionen])
• child_process.execFileSync (datei [, args] [, options])
• child_process.execSync (Befehl [, Optionen])
• child_process.spawnSync (Befehl [, args] [, options])

Bemerkungen

Einen neuen Prozess starten, um einen Befehl auszuführen

Verwenden Sie child_process.spawn() um einen neuen Prozess zu erzeugen, in dem Sie eine ungepufferte Ausgabe benötigen (z. B. lang laufende Prozesse, bei denen die Ausgabe über einen bestimmten Zeitraum gedruckt werden kann und nicht sofort child_process.spawn() .

Diese Methode erzeugt einen neuen Prozess mit einem gegebenen Befehl und einem Array von Argumenten. Der Rückgabewert ist eine Instanz von ChildProcess , die wiederum die Eigenschaften stdout und stderr bereitstellt. Beide Streams sind Instanzen von stream.Readable .

Der folgende Code entspricht der Ausführung des Befehls 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}`);
});

Ein weiterer Beispielbefehl:

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

Könnte geschrieben werden als:

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

Eine Shell starten, um einen Befehl auszuführen

Um einen Befehl in einer Shell auszuführen, in der Sie eine gepufferte Ausgabe benötigen (dh es ist kein Stream), verwenden Sie child_process.exec . Wenn Sie beispielsweise den Befehl cat *.js file | wc -l , ohne Optionen, das würde so aussehen:

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}`);
});

Die Funktion akzeptiert bis zu drei Parameter:

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

Der Befehlsparameter ist eine Zeichenfolge und ist erforderlich, während das Optionsobjekt und der Rückruf optional sind. Wenn kein Optionsobjekt angegeben ist, verwendet exec standardmäßig Folgendes:

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

Das Optionsobjekt unterstützt auch einen shell Parameter (standardmäßig /bin/sh unter UNIX und cmd.exe unter Windows), eine uid Option zum Festlegen der Benutzeridentität des Prozesses und eine gid Option für die Gruppenidentität.

Der Rückruf, der aufgerufen wird, wenn der Befehl ausgeführt wurde, wird mit den drei Argumenten (err, stdout, stderr) aufgerufen. Wenn der Befehl erfolgreich ausgeführt wird, ist err null , andernfalls ist es eine Instanz von Error , wobei err.code der err.code des Prozesses und err.signal das Signal ist, das zur Beendigung gesendet wurde.

Die Argumente stdout und stderr sind die Ausgabe des Befehls. Es wird mit der im options-Objekt angegebenen Kodierung dekodiert (Standard: string ), kann aber ansonsten als Buffer werden.

Es gibt auch eine synchrone Version von exec , nämlich execSync . Die synchrone Version nimmt keinen Rückruf an und gibt stdout anstelle einer Instanz von ChildProcess . Wenn bei der synchronen Version ein Fehler auftritt, wird Ihr Programm ausgelöst und angehalten. Es sieht aus wie das:

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

Einen Prozess starten, um eine ausführbare Datei auszuführen

Wenn Sie eine Datei ausführen child_process.execFile , beispielsweise eine ausführbare Datei, verwenden Sie child_process.execFile . Anstatt eine Shell wie child_process.exec , wird direkt ein neuer Prozess erstellt, der etwas effizienter ist als die Ausführung eines Befehls. Die Funktion kann wie folgt verwendet werden:

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

  console.log(stdout);
});

Im Gegensatz zu child_process.exec akzeptiert diese Funktion bis zu vier Parameter, wobei der zweite Parameter ein Array von Argumenten ist, die Sie der ausführbaren Datei übergeben möchten:

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

Ansonsten sind die Optionen und das Callback-Format ansonsten identisch mit child_process.exec . Gleiches gilt für die synchrone Version der Funktion:

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