Выполнить двоичный файл командной строки с Node.js

Question

Выполнить двоичный файл командной строки с Node.js

Я нахожусь в процессе переноса библиотеки CLI из Ruby в Node.js. В моем коде я выполняю несколько сторонних двоичных файлов, когда это необходимо. Я не уверен, как лучше всего это сделать в Node.

Вот пример в Ruby, где я вызываю PrinceXML для преобразования файла в PDF:

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

Что такое эквивалентный код в Node?

833

javascript node.js ruby command-line-interface

Источник

user1114095 17 дек '13 в 19:56

13 ответов

Другие вопросы по тегам javascript node.js ruby command-line-interface

user1380918 17 дек '13 в 20:02 2013-12-17 20:02 · Answer 1 · 2013-12-17 20:02

Для еще более новой версии 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}`);
});

Вы также можете использовать его с Обещаниями:

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 stdout 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 и более ранних версий.

Модуль для порождения дочерних процессов с Node.js хорошо документирован в документации (v5.0.0). Чтобы выполнить команду и получить ее полный вывод в виде буфера, используйте 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
});

Если вам нужно использовать процессный ввод-вывод с потоками, например, когда вы ожидаете больших объемов вывода, используйте 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, Все методы, описанные выше, являются асинхронными и имеют синхронный аналог. Документацию для них можно найти здесь. Хотя они полезны для сценариев, обратите внимание, что в отличие от методов, используемых для асинхронного порождения дочерних процессов, синхронные методы не возвращают экземпляр ChildProcess,

user4863783 23 фев '16 в 19:18 2016-02-23 19:18 · Answer 2 · 2016-02-23 19:18

Узел JS `v10.9.0`, LTS `v8.11.4`, а также `v6.14.3` --- Авг 2018

Асинхронный и правильный метод:

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

Синхронизация:

'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 v10.9.0

То же самое касается документации Node.js v8.11.4 и документации Node.js v6.14.3

user701875 17 дек '13 в 19:59 2013-12-17 19:59 · Answer 3 · 2013-12-17 19:59

Вы ищете 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}`);
        }
});

88

Источник

user701875 17 дек '13 в 19:59

user884491 25 май '16 в 13:06 2016-05-25 13:06 · Answer 4 · 2016-05-25 13:06

Начиная с версии 4, ближайшая альтернатива child_process.execSync метод:

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

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

Обратите внимание, что этот метод блокирует цикл обработки событий.

50

Источник

user884491 25 май '16 в 13:06

user868791 08 янв '19 в 13:42 2019-01-08 13:42 · Answer 5 · 2019-01-08 13:42

Теперь вы можете использовать shelljs (из узла v4) следующим образом:

var shell = require('shelljs');

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

36

Источник

user868791 08 янв '19 в 13:42

user4551788 15 апр '17 в 14:24 2017-04-15 14:24 · Answer 6 · 2017-04-15 14:24

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

35

Источник

user4551788 15 апр '17 в 14:24

user5645583 24 май '17 в 16:17 2017-05-24 16:17 · Answer 7 · 2017-05-24 16:17

Если вы хотите что-то похожее на верхний ответ, но также синхронный, то это будет работать.

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

var options = {
  encoding: 'utf8'
};

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

34

Источник

user5645583 24 май '17 в 16:17

user2391795 17 май '14 в 13:28 2014-05-17 13:28 · Answer 8 · 2014-05-17 13:28

Я только что написал помощник 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. ---------------');
    });

user10312920 01 сен '19 в 01:44 2019-09-01 01:44 · Answer 9 · 2019-09-01 01:44

Используйте этот легкий npm пакет: system-commands

Посмотрите на это здесь.

Импортируйте это так:

const system = require('system-commands')

Выполните такие команды:

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

14

Источник

user10312920 01 сен '19 в 01:44

user569302 12 окт '18 в 01:56 2018-10-12 01:56 · Answer 10 · 2018-10-12 01:56

Если вы не против зависимости и хотите использовать обещания, 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);
    });

user1242333 28 фев '16 в 19:31 2016-02-28 19:31 · Answer 11 · 2016-02-28 19:31

Ответ @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;

user2857135 03 авг '23 в 14:45 2023-08-03 14:45 · Answer 12 · 2023-08-03 14:45

Узел 16:

      const { execSync } = require('child_process');
execSync('ls'); // your system command

3

Источник

user2857135 03 авг '23 в 14:45

user2796593 30 сен '20 в 16:22 2020-09-30 16:22 · Answer 13 · 2020-09-30 16:22

Вы можете использовать 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 МБ вместо 200 КБ.
Запускает локально установленные двоичные файлы по имени.
Очищает порожденные процессы, когда родительский процесс умирает.
Получите чередующийся вывод из stdout и stderr, аналогичный тому, что выводится на терминал. (Только асинхронный)
Можно указать файл и аргументы как одну строку без оболочки
Более описательные ошибки.

Выполнить двоичный файл командной строки с Node.js

13 ответов

Узел JS v10.9.0, LTS v8.11.4, а также v6.14.3 --- Авг 2018

Узел JS `v10.9.0`, LTS `v8.11.4`, а также `v6.14.3` --- Авг 2018