javascript - nodejs - node program
Ejecutar un binario de línea de comandos con Node.js (9)
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. ---------------'');
});
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?
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.
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 .
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;
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));
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);
});
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}`);
}
});
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
const exec = require("child_process").exec
exec("ls", (error, stdout, stderr) => {
//do whatever here
})