使用Node.js执行命令行二进制文件

时间：2013-12-17 19:56:26

标签： javascript ruby node.js command-line-interface

我正在将一个CLI库从Ruby移植到Node.js。在我的代码中，我在必要时执行几个第三方二进制文件。我不确定在Node中如何最好地完成此任务。

这是Ruby中的一个示例，我将PrinceXML称为将文件转换为PDF：

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

Node中的等效代码是什么？

12 个答案:

答案 0 :(得分：872)

对于更新版本的Node.js（v8.1.4），事件和调用与旧版本类似或相同，但鼓励使用标准的新语言功能。例子：

对于缓冲的非流格式化输出（您可以一次性完成所有操作），请使用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}`);
});

您也可以将它与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();

如果您希望以块的形式逐渐接收数据（以流形式输出），请使用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}`);
});

这两个功能都有同步对应物。 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');

以及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);

注意：以下代码仍然有效，但主要针对ES5及之前的用户。

documentation（v5.0.0）中详细记录了使用Node.js生成子进程的模块。要执行命令并将其完整输出作为缓冲区获取，请使用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
});

如果您需要对流使用句柄处理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);

如果您正在执行文件而不是命令，则可能需要使用child_process.execFile，哪些参数几乎与spawn相同，但有第四个回调参数，如exec用于检索输出缓冲区。这可能看起来像这样：

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

从v0.11.12开始，Node现在支持同步spawn和exec。上述所有方法都是异步的，并且具有同步对应物。可以找到他们的文档here。虽然它们对脚本很有用，但请注意，与用于异步生成子进程的方法不同，同步方法不返回ChildProcess的实例。

答案 1 :(得分：211)

节点JS v12.2.0，LTS v10.15.3和v8.16.0 --- 2019年5月

异步方法（Unix）： 

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


异步方法（Windows）： 

'use strict';

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


同步 

'use strict';

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

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

来自Node.js v12.2.0 Documentation

Node.js v10.15.3 Documentation和Node.js v8.16.0 Documentation

也是如此

答案 2 :(得分：63)

您正在寻找child_process.exec

以下是示例：

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 :(得分：26)

y

答案 4 :(得分：18)

如果您想要的东西与top answer非常相似，但也是同步的，那么这将有效。

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

var options = {
  encoding: 'utf8'
};

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

答案 5 :(得分：17)

从版本4开始，最接近的替代方法是child_process.execSync方法：

const {execSync} = require('child_process');

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

请注意，此方法会阻止事件循环。

答案 6 :(得分：13)

我刚刚写了一个Cli助手来轻松处理Unix / windows。

<强>使用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;
});

打字稿原始源文件： 

 /**
 * 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. ---------------');
    });

答案 7 :(得分：5)

如果您不介意依赖项，而是想使用Promise，child-process-promise可以起作用：

安装 

npm install child-process-promise --save

exec用法 

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

衍生使用 

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

答案 8 :(得分：2)

现在，您可以按如下方式使用shelljs（来自节点v4）：

var shell = require('shelljs');

shell.echo('hello world');
shell.exec('node --version')

答案 9 :(得分：1)

@ hexacyanide的回答几乎是完整的。 在Windows上，命令prince可以是prince.exe，prince.cmd，prince.bat或仅prince（我不知道如何捆绑宝石，但是npm垃圾箱附带一个sh脚本和一个批处理脚本 - npm和npm.cmd）。 如果你想编写一个可在Unix和Windows上运行的可移植脚本，你必须生成正确的可执行文件。

这是一个简单但可移植的spawn函数：

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;

答案 10 :(得分：1)

使用此轻量级npm软件包： system-commands

看看here。

这样导入：

const system = require('system-commands')

运行如下命令：

system('ls').then(output => {
    console.log(output)
}).catch(error => {
    console.error(error)
})

答案 11 :(得分：-1)

您可以使用execa。

例如，作为承诺：

const execa = require('execa')

execa('cat *.js bad_file').then(
  (childProcessResult) => {
    //onFulfilled
    console.log('Success!', childProcessResult)
  },
  (childProcessResult) => {
    //onRejected
    console.log('Error!', childProcessResult)
  }
)

Execa通过以下方式改进了child_process方法：

  • 承诺界面。
  • 从输出中剥离最后的换行符，因此您不必执行stdout.trim()。
  • 支持shebang二进制跨平台
    • 。
  • 改进的Windows支持。
  • 更高的最大缓冲区。 100 MB而不是200 KB。
  • 按名称执行本地安装的二进制文件。
  • 父进程死亡时清理产生的进程。
  • 从stdout和stderr获取交错输出，类似于在终端上打印的输出。 （仅异步）
  • 可以将文件和参数指定为没有外壳的单个字符串
  • 更多描述性错误。
相关问题
最新问题