Esegui e ottieni l'output di un comando di shell in node.js

In un node.js, vorrei trovare un modo per ottenere l'output di un comando da terminale Unix. C'è un modo per fare questo?

function getCommandOutput(commandString){
    // now how can I implement this function?
    // getCommandOutput("ls") should print the terminal output of the shell command "ls"
}

Questo è il modo in cui lo faccio in un progetto a cui sto lavorando ora.

var exec = require('child_process').exec;
function execute(command, callback){
    exec(command, function(error, stdout, stderr){ callback(stdout); });
};

Esempio: recupero dell'utente git

module.exports.getGitUser = function(callback){
    execute("git config --global user.name", function(name){
        execute("git config --global user.email", function(email){
            callback({ name: name.replace("\n", ""), email: email.replace("\n", "") });
        });
    });
};

Stai cercando child_process

var exec = require('child_process').exec;
var child;

child = exec(command,
   function (error, stdout, stderr) {
      console.log('stdout: ' + stdout);
      console.log('stderr: ' + stderr);
      if (error !== null) {
          console.log('exec error: ' + error);
      }
   });

Come sottolineato da Renato, ci sono anche alcuni pacchetti exec sincroni ora disponibili, vedi sync-exec che potrebbe essere più quello che stai cercando. Tieni presente, tuttavia, che node.js è progettato per essere un server di rete ad alte prestazioni con thread singolo, quindi se è per questo che stai cercando di usarlo, stai lontano da cose di tipo sync-exec a meno che tu non lo usi solo durante l'avvio o qualcosa.

Se stai usando node dopo la 7.6 e non ti piace lo stile di callback, puoi anche usare la promisifyfunzione di node-util con async / awaitper ottenere comandi di shell che leggono in modo pulito. Ecco un esempio della risposta accettata, utilizzando questa tecnica:

const { promisify } = require('util');
const exec = promisify(require('child_process').exec)

module.exports.getGitUser = async function getGitUser () {
  const name = await exec('git config --global user.name')
  const email = await exec('git config --global user.email')
  return { name, email }
};

Questo ha anche l'ulteriore vantaggio di restituire una promessa rifiutata su comandi non riusciti, che può essere gestita try / catchall'interno del codice asincrono.

Grazie alla risposta di Renato, ho creato un esempio davvero semplice:

const exec = require('child_process').exec

exec('git config --global user.name', (err, stdout, stderr) => console.log(stdout))

Stamperà solo il tuo nome utente git globale :)

Requisiti

Ciò richiederà Node.js 7 o versioni successive con supporto per Promises e Async / Await.

Soluzione

Crea una funzione wrapper che faccia leva sulle promesse di controllare il comportamento del child_process.execcomando.

Spiegazione

Utilizzando promesse e una funzione asincrona, puoi imitare il comportamento di una shell che restituisce l'output, senza cadere in un inferno di callback e con un'API piuttosto ordinata. Usando la awaitparola chiave, puoi creare uno script che si legge facilmente, pur essendo in grado di portare a termine il lavoro child_process.exec.

Esempio di codice

const childProcess = require("child_process");

/**
 * @param {string} command A shell command to execute
 * @return {Promise<string>} A promise that resolve to the output of the shell command, or an error
 * @example const output = await execute("ls -alh");
 */
function execute(command) {
  /**
   * @param {Function} resolve A function that resolves the promise
   * @param {Function} reject A function that fails the promise
   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise
   */
  return new Promise(function(resolve, reject) {
    /**
     * @param {Error} error An error triggered during the execution of the childProcess.exec command
     * @param {string|Buffer} standardOutput The result of the shell command execution
     * @param {string|Buffer} standardError The error resulting of the shell command execution
     * @see https://nodejs.org/api/child_process.html#child_process_child_process_exec_command_options_callback
     */
    childProcess.exec(command, function(error, standardOutput, standardError) {
      if (error) {
        reject();

        return;
      }

      if (standardError) {
        reject(standardError);

        return;
      }

      resolve(standardOutput);
    });
  });
}

uso

async function main() {
  try {
    const passwdContent = await execute("cat /etc/passwd");

    console.log(passwdContent);
  } catch (error) {
    console.error(error.toString());
  }

  try {
    const shadowContent = await execute("cat /etc/shadow");

    console.log(shadowContent);
  } catch (error) {
    console.error(error.toString());
  }
}

main();

Output di esempio

root:x:0:0::/root:/bin/bash
[output trimmed, bottom line it succeeded]

Error: Command failed: cat /etc/shadow
cat: /etc/shadow: Permission denied

Provalo online.

Repl.it .

Risorse esterne

Promesse .

child_process.exec.

Piano di appoggio Node.js .