javascript - nodejs - node program

Ejecutar un binario de línea de comandos con Node.js

Question

Estoy en el proceso de portar una biblioteca CLI de Ruby a Node.js. En mi código ejecuto varios binarios de terceros cuando es necesario. No estoy seguro de cómo lograr esto mejor en Nodo.

Aquí hay un ejemplo en Ruby donde llamo a PrinceXML para convertir un archivo a PDF:

cmd = system("prince -v builds/pdf/book.html -o builds/pdf/book.pdf")

¿Cuál es el código equivalente en Nodo?

Answer 1

Acabo de escribir un ayudante Cli para tratar con Unix / Windows fácilmente.

Javascript:

define(["require", "exports"], function (require, exports) {
    /**
     * Helper to use the Command Line Interface (CLI) easily with both Windows and Unix environments.
     * Requires underscore or lodash as global through "_".
     */
    var Cli = (function () {
        function Cli() {}
            /**
             * Execute a CLI command.
             * Manage Windows and Unix environment and try to execute the command on both env if fails.
             * Order: Windows -> Unix.
             *
             * @param command                   Command to execute. (''grunt'')
             * @param args                      Args of the command. (''watch'')
             * @param callback                  Success.
             * @param callbackErrorWindows      Failure on Windows env.
             * @param callbackErrorUnix         Failure on Unix env.
             */
        Cli.execute = function (command, args, callback, callbackErrorWindows, callbackErrorUnix) {
            if (typeof args === "undefined") {
                args = [];
            }
            Cli.windows(command, args, callback, function () {
                callbackErrorWindows();

                try {
                    Cli.unix(command, args, callback, callbackErrorUnix);
                } catch (e) {
                    console.log(''------------- Failed to perform the command: "'' + command + ''" on all environments. -------------'');
                }
            });
        };

        /**
         * Execute a command on Windows environment.
         *
         * @param command       Command to execute. (''grunt'')
         * @param args          Args of the command. (''watch'')
         * @param callback      Success callback.
         * @param callbackError Failure callback.
         */
        Cli.windows = function (command, args, callback, callbackError) {
            if (typeof args === "undefined") {
                args = [];
            }
            try {
                Cli._execute(process.env.comspec, _.union([''/c'', command], args));
                callback(command, args, ''Windows'');
            } catch (e) {
                callbackError(command, args, ''Windows'');
            }
        };

        /**
         * Execute a command on Unix environment.
         *
         * @param command       Command to execute. (''grunt'')
         * @param args          Args of the command. (''watch'')
         * @param callback      Success callback.
         * @param callbackError Failure callback.
         */
        Cli.unix = function (command, args, callback, callbackError) {
            if (typeof args === "undefined") {
                args = [];
            }
            try {
                Cli._execute(command, args);
                callback(command, args, ''Unix'');
            } catch (e) {
                callbackError(command, args, ''Unix'');
            }
        };

        /**
         * Execute a command no matters what''s the environment.
         *
         * @param command   Command to execute. (''grunt'')
         * @param args      Args of the command. (''watch'')
         * @private
         */
        Cli._execute = function (command, args) {
            var spawn = require(''child_process'').spawn;
            var childProcess = spawn(command, args);

            childProcess.stdout.on("data", function (data) {
                console.log(data.toString());
            });

            childProcess.stderr.on("data", function (data) {
                console.error(data.toString());
            });
        };
        return Cli;
    })();
    exports.Cli = Cli;
});

Archivo fuente original mecanografiado:

 /**
 * Helper to use the Command Line Interface (CLI) easily with both Windows and Unix environments.
 * Requires underscore or lodash as global through "_".
 */
export class Cli {

    /**
     * Execute a CLI command.
     * Manage Windows and Unix environment and try to execute the command on both env if fails.
     * Order: Windows -> Unix.
     *
     * @param command                   Command to execute. (''grunt'')
     * @param args                      Args of the command. (''watch'')
     * @param callback                  Success.
     * @param callbackErrorWindows      Failure on Windows env.
     * @param callbackErrorUnix         Failure on Unix env.
     */
    public static execute(command: string, args: string[] = [], callback ? : any, callbackErrorWindows ? : any, callbackErrorUnix ? : any) {
        Cli.windows(command, args, callback, function () {
            callbackErrorWindows();

            try {
                Cli.unix(command, args, callback, callbackErrorUnix);
            } catch (e) {
                console.log(''------------- Failed to perform the command: "'' + command + ''" on all environments. -------------'');
            }
        });
    }

    /**
     * Execute a command on Windows environment.
     *
     * @param command       Command to execute. (''grunt'')
     * @param args          Args of the command. (''watch'')
     * @param callback      Success callback.
     * @param callbackError Failure callback.
     */
    public static windows(command: string, args: string[] = [], callback ? : any, callbackError ? : any) {
        try {
            Cli._execute(process.env.comspec, _.union([''/c'', command], args));
            callback(command, args, ''Windows'');
        } catch (e) {
            callbackError(command, args, ''Windows'');
        }
    }

    /**
     * Execute a command on Unix environment.
     *
     * @param command       Command to execute. (''grunt'')
     * @param args          Args of the command. (''watch'')
     * @param callback      Success callback.
     * @param callbackError Failure callback.
     */
    public static unix(command: string, args: string[] = [], callback ? : any, callbackError ? : any) {
        try {
            Cli._execute(command, args);
            callback(command, args, ''Unix'');
        } catch (e) {
            callbackError(command, args, ''Unix'');
        }
    }

    /**
     * Execute a command no matters what''s the environment.
     *
     * @param command   Command to execute. (''grunt'')
     * @param args      Args of the command. (''watch'')
     * @private
     */
    private static _execute(command, args) {
        var spawn = require(''child_process'').spawn;
        var childProcess = spawn(command, args);

        childProcess.stdout.on("data", function (data) {
            console.log(data.toString());
        });

        childProcess.stderr.on("data", function (data) {
            console.error(data.toString());
        });
    }
}

Example of use:

    Cli.execute(Grunt._command, args, function (command, args, env) {
        console.log(''Grunt has been automatically executed. ('' + env + '')'');

    }, function (command, args, env) {
        console.error(''------------- Windows "'' + command + ''" command failed, trying Unix... ---------------'');

    }, function (command, args, env) {
        console.error(''------------- Unix "'' + command + ''" command failed too. ---------------'');
    });

Answer 2

Desde la versión 4, la alternativa más cercana es el método child_process.execSync :

const execSync = require(''child_process'').execSync;

var cmd = execSync(''prince -v builds/pdf/book.html -o builds/pdf/book.pdf'');

Tenga en cuenta que este método bloquea el bucle de eventos.

Answer 3

Incluso para la versión más reciente de Node.js (v8.1.4), los eventos y las llamadas son similares o idénticas a las versiones anteriores, pero se recomienda utilizar las funciones de idioma estándar más nuevas. Ejemplos:

Para una salida con formato en búfer y sin transmisión (lo obtiene todo de una vez), use child_process.exec :

const { exec } = require(''child_process'');
exec(''cat *.js bad_file | wc -l'', (err, stdout, stderr) => {
  if (err) {
    // node couldn''t execute the command
    return;
  }

  // the *entire* stdout and stderr (buffered)
  console.log(`stdout: ${stdout}`);
  console.log(`stderr: ${stderr}`);
});

También puedes usarlo con Promesas:

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

async function ls() {
  const { stdout, stderr } = await exec(''ls'');
  console.log(''stdout:'', stdout);
  console.log(''stderr:'', stderr);
}
ls();

Si desea recibir los datos gradualmente en fragmentos (salida como una transmisión), use child_process.spawn :

const { spawn } = require(''child_process'');
const child = spawn(''ls'', [''-lh'', ''/usr'']);

// use child.stdout.setEncoding(''utf8''); if you want text chunks
child.stdout.on(''data'', (chunk) => {
  // data from standard output is here as buffers
});

// since these are streams, you can pipe them elsewhere
child.stderr.pipe(dest);

child.on(''close'', (code) => {
  console.log(`child process exited with code ${code}`);
});

Ambas funciones tienen una contraparte síncrona. Un ejemplo para child_process.execSync :

const { execSync } = require(''child_process'');
// stderr is sent to stdout of parent process
// you can set options.stdio if you want it to go elsewhere
let stdout = execSync(''ls'');

Además de child_process.spawnSync :

const { spawnSync} = require(''child_process'');
const child = spawnSync(''ls'', [''-lh'', ''/usr'']);

console.log(''error'', child.error);
console.log(''stdout '', child.stdout);
console.log(''stderr '', child.stderr);

Nota: el siguiente código sigue siendo funcional, pero está dirigido principalmente a los usuarios de ES5 y anteriores.

El módulo para generar procesos secundarios con Node.js está bien documentado en la documentation (v5.0.0). Para ejecutar un comando y obtener su salida completa como un búfer, use child_process.exec :

var exec = require(''child_process'').exec;
var cmd = ''prince -v builds/pdf/book.html -o builds/pdf/book.pdf'';

exec(cmd, function(error, stdout, stderr) {
  // command output is in stdout
});

Si necesita usar la E / S del proceso de manejo con secuencias, como cuando espera grandes cantidades de resultados, use child_process.spawn :

var spawn = require(''child_process'').spawn;
var child = spawn(''prince'', [
  ''-v'', ''builds/pdf/book.html'',
  ''-o'', ''builds/pdf/book.pdf''
]);

child.stdout.on(''data'', function(chunk) {
  // output will be here in chunks
});

// or if you want to send output elsewhere
child.stdout.pipe(dest);

Si está ejecutando un archivo en lugar de un comando, es posible que desee usar child_process.execFile , cuyos parámetros son casi idénticos a los spawn , pero tiene un cuarto parámetro de devolución de llamada como exec para recuperar buffers de salida. Eso podría verse un poco así:

var execFile = require(''child_process'').execFile;
execFile(file, args, options, function(error, stdout, stderr) {
  // command output is in stdout
});

A partir de v0.11.12 , Node ahora es compatible con spawn y exec síncronos Todos los métodos descritos anteriormente son asíncronos y tienen una contraparte síncrona. La documentación para ellos se puede encontrar here . Si bien son útiles para las secuencias de comandos, tenga en cuenta que, a diferencia de los métodos utilizados para generar procesos secundarios de forma asíncrona, los métodos síncronos no devuelven una instancia de ChildProcess .

Answer 4

La respuesta de @hexacyanide es casi completa. En el comando de Windows, prince puede ser prince.exe , prince.cmd , prince.bat o simplemente prince (no conozco cómo se agrupan las gemas, pero los npm bins vienen con un script sh y un script por lotes: npm y npm.cmd ). Si desea escribir un script portátil que se ejecute en Unix y Windows, debe generar el ejecutable correcto.

Aquí hay una función de creación simple pero portátil:

function spawn(cmd, args, opt) {
    var isWindows = /win/.test(process.platform);

    if ( isWindows ) {
        if ( !args ) args = [];
        args.unshift(cmd);
        args.unshift(''/c'');
        cmd = process.env.comspec;
    }

    return child_process.spawn(cmd, args, opt);
}

var cmd = spawn("prince", ["-v", "builds/pdf/book.html", "-o", "builds/pdf/book.pdf"])

// Use these props to get execution results:
// cmd.stdin;
// cmd.stdout;
// cmd.stderr;

Answer 5

Si desea algo que se parezca mucho a la respuesta principal pero también sea sincrónico, esto funcionará.

var execSync = require(''child_process'').execSync;
var cmd = "echo ''hello world''";

var options = {
  encoding: ''utf8''
};

console.log(execSync(cmd, options));

Answer 6

Si no te importa una dependencia y quieres usar promesas, child-process-promise funciona:

instalación

npm install child-process-promise --save

uso del ejecutivo

var exec = require(''child-process-promise'').exec;

exec(''echo hello'')
    .then(function (result) {
        var stdout = result.stdout;
        var stderr = result.stderr;
        console.log(''stdout: '', stdout);
        console.log(''stderr: '', stderr);
    })
    .catch(function (err) {
        console.error(''ERROR: '', err);
    });

uso del spawn

var spawn = require(''child-process-promise'').spawn;

var promise = spawn(''echo'', [''hello'']);

var childProcess = promise.childProcess;

console.log(''[spawn] childProcess.pid: '', childProcess.pid);
childProcess.stdout.on(''data'', function (data) {
    console.log(''[spawn] stdout: '', data.toString());
});
childProcess.stderr.on(''data'', function (data) {
    console.log(''[spawn] stderr: '', data.toString());
});

promise.then(function () {
        console.log(''[spawn] done!'');
    })
    .catch(function (err) {
        console.error(''[spawn] ERROR: '', err);
    });

Answer 7

Usted está buscando child_process.exec

Aquí está el ejemplo:

const exec = require(''child_process'').exec;
const child = exec(''cat *.js bad_file | wc -l'',
    (error, stdout, stderr) => {
        console.log(`stdout: ${stdout}`);
        console.log(`stderr: ${stderr}`);
        if (error !== null) {
            console.log(`exec error: ${error}`);
        }
});

Answer 8

Nodo JS v10.9.0 , LTS v8.11.4 y v6.14.3 --- Ago 2018

Método asíncrono y propio:

''use strict'';

const
    { spawn } = require( ''child_process'' ),
    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}` );
} );

Sincronizar

''use strict'';

const
    { spawnSync } = require( ''child_process'' ),
    ls = spawnSync( ''ls'', [ ''-lh'', ''/usr'' ] );

console.log( `stderr: ${ls.stderr.toString()}` );
console.log( `stdout: ${ls.stdout.toString()}` );

Desde Node.js v10.9.0 Documentación

Lo mismo ocurre con la documentación Node.js v8.11.4 y la documentación Node.js v6.14.3

Answer 9

const exec = require("child_process").exec
exec("ls", (error, stdout, stderr) => {
 //do whatever here
})