Node.js
Bestanden of opdrachten uitvoeren met onderliggende processen

Syntaxis

• child_process.exec (commando [, opties] [, terugbellen])
• child_process.execFile (bestand [, args] [, opties] [, callback])
• child_process.fork (modulePath [, args] [, options])
• child_process.spawn (commando [, args] [, opties])
• child_process.execFileSync (bestand [, args] [, opties])
• child_process.execSync (commando [, opties])
• child_process.spawnSync (commando [, args] [, opties])

Opmerkingen

Een nieuw proces voortbrengen om een opdracht uit te voeren

Gebruik child_process.spawn() om een nieuw proces te spawnen waarin u niet- gebufferde uitvoer nodig hebt (bijvoorbeeld langlopende processen die mogelijk gedurende een bepaalde periode uitvoer afdrukken in plaats van onmiddellijk af te drukken en af te child_process.spawn() .

Deze methode levert een nieuw proces op met een gegeven opdracht en een reeks argumenten. De retourwaarde is een instantie van ChildProcess , die op zijn beurt de eigenschappen stdout en stderr biedt. Beide streams zijn instanties van stream.Readable .

De volgende code komt overeen met het uitvoeren van de opdracht 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}`);
});

Nog een voorbeeldopdracht:

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

Kan worden geschreven als:

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

Een shell uitzetten om een commando uit te voeren

Gebruik child_process.exec om een opdracht in een shell uit te voeren, waarin u gebufferde uitvoer nodig hebt (dat wil zeggen, het is geen stream). Als u bijvoorbeeld de opdracht cat *.js file | wc -l , zonder opties, dat zou er zo uitzien:

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

De functie accepteert maximaal drie parameters:

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

De opdrachtparameter is een tekenreeks en is vereist, terwijl het optiesobject en callback beide optioneel zijn. Als er geen optieobject is opgegeven, gebruikt exec standaard het volgende:

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

Het optieobject ondersteunt ook een shell parameter, die standaard /bin/sh op UNIX en cmd.exe op Windows, een uid optie voor het instellen van de gebruikersidentiteit van het proces en een gid optie voor de groepsidentiteit.

De callback, die wordt aangeroepen wanneer de opdracht is uitgevoerd, wordt aangeroepen met de drie argumenten (err, stdout, stderr) . Als de opdracht met succes wordt uitgevoerd, is err null , anders is er sprake van een Error , waarbij err.code de err.code van het proces is en err.signal het signaal is dat is verzonden om het te beëindigen.

De argumenten stdout en stderr zijn de uitvoer van de opdracht. Het wordt gedecodeerd met de codering die is opgegeven in het optieobject (standaard: string ), maar kan anders worden geretourneerd als een Buffer .

Er bestaat ook een synchrone versie van exec , die execSync . De synchrone versie wordt niet teruggebeld en retourneert stdout plaats van een exemplaar van ChildProcess . Als de synchrone versie een fout tegenkomt, zal het uw programma gooien en stoppen. Het ziet er zo uit:

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

Een proces voortzetten om een uitvoerbaar bestand uit te voeren

Als u een bestand wilt uitvoeren, zoals een uitvoerbaar bestand, gebruikt u child_process.execFile . In plaats van een shell te spawnen zoals child_process.exec zou doen, zal het direct een nieuw proces maken, dat iets efficiënter is dan het uitvoeren van een opdracht. De functie kan als volgt worden gebruikt:

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

  console.log(stdout);
});

In tegenstelling tot child_process.exec accepteert deze functie maximaal vier parameters, waarbij de tweede parameter een reeks argumenten is die u aan het uitvoerbare bestand wilt geven:

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

Anders zijn de opties en het terugbelformaat anders identiek aan child_process.exec . Hetzelfde geldt voor de synchrone versie van de functie:

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