本文翻译自：Execute a command line binary with Node.js
I am in the process of porting a CLI library from Ruby over to Node.js. 我正在将CLI库从Ruby移植到Node.js。 In my code I execute several third party binaries when necessary. 在我的代码中，如有必要，我将执行几个第三方二进制文件。 I am not sure how best to accomplish this in Node. 我不确定如何最好地在Node中完成此操作。
Here's an example in Ruby where I call PrinceXML to convert a file to a PDF: 这是Ruby中的一个示例，其中我调用PrinceXML将文件转换为PDF：
cmd = system("prince -v builds/pdf/book.html -o builds/pdf/book.pdf")
What is the equivalent code in Node? Node中的等效代码是什么？
#1楼
参考：https://stackoom.com/question/1OcJC/使用Node-js执行命令行二进制文件
#2楼
You are looking for child_process.exec 您正在寻找child_process.exec
Here is the example: 这是示例：
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}`);
}
});
#3楼
For even newer version of Node.js (v8.1.4), the events and calls are similar or identical to older versions, but it's encouraged to use the standard newer language features. 对于更高版本的Node.js（v8.1.4），事件和调用与旧版本相似或相同，但建议使用标准的新语言功能。 Examples: 例子：
For buffered, non-stream formatted output (you get it all at once), use child_process.exec : 对于缓冲的，非流格式的输出（您一次全部获得），请使用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}`);
});
You can also use it with Promises: 您还可以将其与Promises一起使用：
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();
If you wish to receive the data gradually in chunks (output as a stream), use child_process.spawn : 如果您希望逐步接收数据块（作为流输出），请使用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}`);
});
Both of these functions have a synchronous counterpart. 这两个功能都有一个同步对应项。 An example for child_process.execSync : child_process.execSync的示例：
const { execSync } = require('child_process');
// stderr is sent to stderr of parent process
// you can set options.stdio if you want it to go elsewhere
let stdout = execSync('ls');
As well as child_process.spawnSync : 以及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);
Note: The following code is still functional, but is primarily targeted at users of ES5 and before. 注意：以下代码仍可正常运行，但主要针对ES5及更高版本的用户。
The module for spawning child processes with Node.js is well documented in the documentation (v5.0.0). 在文档 （v5.0.0）中很好地记录了使用Node.js生成子进程的模块。 To execute a command and fetch its complete output as a buffer, use child_process.exec : 要执行命令并获取其完整的输出作为缓冲区，请使用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
});
If you need to use handle process I/O with streams, such as when you are expecting large amounts of output, use child_process.spawn : 如果您需要child_process.spawn使用句柄进程I / O，例如当您期望大量输出时，请使用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);
If you are executing a file rather than a command, you might want to use child_process.execFile , which parameters which are almost identical to spawn , but has a fourth callback parameter like exec for retrieving output buffers. 如果您执行的是文件而不是命令，则可能要使用child_process.execFile ，该参数与spawn几乎相同，但是具有第四个回调参数，例如exec用于检索输出缓冲区。 That might look a bit like this: 可能看起来像这样：
var execFile = require('child_process').execFile;
execFile(file, args, options, function(error, stdout, stderr) {
// command output is in stdout
});
As of v0.11.12 , Node now supports synchronous spawn and exec . 从v0.11.12开始 ，Node现在支持同步spawn和exec 。 All of the methods described above are asynchronous, and have a synchronous counterpart. 上述所有方法都是异步的，并且具有同步的对应方法。 Documentation for them can be found here . 它们的文档可以在这里找到。 While they are useful for scripting, do note that unlike the methods used to spawn child processes asynchronously, the synchronous methods do not return an instance of ChildProcess . 尽管它们对于脚本编写很有用，但请注意，与用于异步生成子进程的方法不同，同步方法不会返回ChildProcess的实例。
#4楼
I just wrote a Cli helper to deal with Unix/windows easily. 我只是写了一个Cli帮助程序来轻松处理Unix / windows。
Javascript: 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;
});
Typescript original source file: Typescript原始源文件：
/**
* 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. ---------------');
});
#5楼
Node JS v12.9.1 , LTS v10.16.3 , and v8.16.1 --- Aug 2019 Node JS v12.9.1 ，LTS v10.16.3和v8.16.1 --- Aug 2019
Async method (Unix): 异步方法（Unix）：
'use strict';
const { spawn } = require( 'child_process' );
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}` );
} );
Async method (Windows): 异步方法（Windows）：
'use strict';
const { spawn } = require( 'child_process' );
const dir = spawn( 'dir', [ '.' ] );
dir.stdout.on( 'data', data => console.log( `stdout: ${data}` ) );
dir.stderr.on( 'data', data => console.log( `stderr: ${data}` ) );
dir.on( 'close', code => console.log( `child process exited with code ${code}` ) );
Sync: 同步：
'use strict';
const { spawnSync } = require( 'child_process' );
const ls = spawnSync( 'ls', [ '-lh', '/usr' ] );
console.log( `stderr: ${ls.stderr.toString()}` );
console.log( `stdout: ${ls.stdout.toString()}` );
From Node.js v12.9.1 Documentation 从Node.js v12.9.1文档
The same goes for Node.js v10.16.3 Documentation and Node.js v8.16.1 Documentation Node.js v10.16.3文档和Node.js v8.16.1文档也是如此
#6楼
@hexacyanide's answer is almost a complete one. @hexacyanide的答案几乎是完整的答案。 On Windows command prince could be prince.exe , prince.cmd , prince.bat or just prince (I'm no aware of how gems are bundled, but npm bins come with a sh script and a batch script - npm and npm.cmd ). 在Windows命令prince可能是prince.exe ， prince.cmd ， prince.bat或者只是prince （我不知道的宝石捆绑的方式，但NPM箱都配有SH脚本，批处理脚本- npm和npm.cmd ）。 If you want to write a portable script that would run on Unix and Windows, you have to spawn the right executable. 如果要编写可在Unix和Windows上运行的可移植脚本，则必须生成正确的可执行文件。
Here is a simple yet portable spawn function: 这是一个简单但可移植的生成函数：
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;
2793
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
