Node.js
Utför filer eller kommandon med Child Processes

Syntax

• child_process.exec (kommando [, alternativ] [, återuppringning])
• child_process.execFile (fil [, args] [, alternativ] [, återuppringning])
• child_process.fork (modulePath [, args] [, optioner])
• child_process.spawn (kommando [, args] [, alternativ])
• child_process.execFileSync (fil [, args] [, alternativ])
• child_process.execSync (kommando [, alternativ])
• child_process.spawnSync (kommando [, args] [, alternativ])

Anmärkningar

Att leka en ny process för att köra ett kommando

Använd child_process.spawn () för att leka en ny process där du behöver outbuffrad utmatning (t.ex. processer med lång drift som kan skriva ut under en viss tid istället för att skriva ut och avsluta omedelbart child_process.spawn() .

Denna metod skapar en ny process med ett givet kommando och en rad argument. ChildProcess är ett exempel på ChildProcess , som i sin tur ger stdout och stderr egenskaperna. Båda dessa strömmar är instanser av stream.Readable . stream.Readable .

Följande kod motsvarar användning av kommandot 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}`);
});

Ett annat exempel på kommando:

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

Kan skrivas som:

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

Att leka ett skal för att utföra ett kommando

child_process.exec köra ett kommando i ett skal, där du krävde buffrad utdata (dvs. det är inte en ström). Om du till exempel vill köra kommandokatten cat *.js file | wc -l , utan några alternativ, det skulle se ut så här:

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

Funktionen accepterar upp till tre parametrar:

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

Kommandoparametern är en sträng och krävs medan alternativobjektet och återuppringning båda är valfria. Om inget alternativobjekt specificeras, kommer exec att använda följande som standard:

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

Alternativen motsätter stöder också en shell som är standard /bin/sh på UNIX och cmd.exe på Windows, en uid alternativ för inställning av användaridentitet i processen, och en gid alternativ för gruppidentitet.

Återuppringningen, som kallas när kommandot är genomfört, kallas med de tre argumenten (err, stdout, stderr) . Om kommandot körs framgångsrikt kommer err att vara null , annars kommer det att vara en instans av Error , med err.code är processens err.signal och err.signal är signalen som skickades för att avsluta den.

stdout och stderr argumenten är utgången från kommandot. Den avkodas med den kodning som anges i alternativobjektet (standard: string ), men kan annars returneras som ett Buffer .

Det finns också en synkron version av exec , som är execSync . Den synkrona versionen tar ingen återuppringning och kommer att returnera stdout istället för en instans av ChildProcess . Om den synkrona versionen stöter på ett fel kommer det att kasta och stoppa ditt program. Det ser ut så här:

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

Lektar en process för att köra en körbar

Om du vill köra en fil, t.ex. en körbar, använder du child_process.execFile . Istället för att leka ett skal som child_process.exec skulle, skapar det direkt en ny process, som är lite effektivare än att köra ett kommando. Funktionen kan användas så:

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

  console.log(stdout);
});

Till skillnad från child_process.exec kommer den här funktionen att acceptera upp till fyra parametrar, där den andra parametern är en rad argument som du vill lämna till den körbara:

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

Annars är alternativen och återuppringningsformatet i övrigt identiska med child_process.exec . Detsamma gäller för den synkrona versionen av funktionen:

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