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

649

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

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

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

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

Дэйв Томпсон
источник
3
Эта библиотека - хорошее место для начала. Это позволяет вам порождать процессы на всех платформах os.
Обсидиан
2
Проще всего использовать child_process.exec, вот несколько хороших примеров
drorw

Ответы:

1070

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

Модуль для порождения дочерних процессов с 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.

hexacyanide
источник
19
БЛАГОДАРЮ ВАС. Это сводило меня с ума. Иногда это помогает просто указать на очевидное решение, чтобы мы, новички (к узлу), могли учиться и работать с ним.
Дейв Томпсон
10
Примечание: require ('child_process'). ExecFile () будет интересен для людей, которым нужно запустить файл, а не общесистемную известную команду, такую ​​как prince, здесь.
Луи Амелин
2
Вместо child.pipe(dest)(которого не существует) вы должны использовать child.stdout.pipe(dest)и child.stderr.pipe(dest), например, child.stdout.pipe(process.stdout)и child.stderr.pipe(process.stderr).
ComFreek
Что если я не хочу помещать все в файл, но хочу выполнить более одной команды? Может быть, как echo "hello"и echo "world".
Кэмерон
это стандартный способ сделать это? Я имею в виду, как все оболочки написаны в nodejs? Я имею в виду, скажем, для gearman, rabbitmq и т. д., которые требуют запуска команды, но у них также есть некоторая оболочка, но я не могу найти ни один из этого кода в коде их библиотеки
ANinJa
261

Узел JS v13.9.0, LTS v12.16.1и v10.19.0 --- Март 2020

Асинхронный метод (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}` );
} );


Асинхронный метод (Windows):

'use strict';

const { spawn } = require( 'child_process' );
const dir = spawn('cmd', ['/c', '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' );
const ls = spawnSync( 'ls', [ '-lh', '/usr' ] );

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

Из документации Node.js v13.9.0

То же самое относится и к Node.js v12.16.1 документации и Node.js v10.19.0 документации

iSkore
источник
8
Спасибо за предоставление как правильных, так и простых версий. Немного более простая версия синхронизации полностью подошла для моего сценария «сделай что-нибудь и выбрось», который мне был нужен.
Брайан Джорден
Нет проблем! Всегда приятно иметь и то, и другое, даже если это не совсем правильно.
iSkore
7
Стоит отметить, что для того, чтобы сделать этот пример в Windows, нужно использовать 'cmd', ['/c', 'dir']. По крайней мере, я просто искал высоко и низко, почему 'dir'без аргументов не работает, прежде чем я запомнил это ...;)
AndyO
1
Ничего из этого не выводит НИЧЕГО на консоль.
Tyguy7
@ Tyguy7 как дела? И есть ли у вас какие-либо переопределения на объекте консоли?
iSkore
73

Вы ищете 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}`);
        }
});
Андрей Карпушонак
источник
Это правильно. Но имейте в виду, что этот тип вызова дочернего процесса имеет ограничения по длине стандартного вывода.
hgoebl
@hgoebl, какова альтернатива?
Harshdeep
2
@Harshdeep в случае длинных выходов стандартного вывода (например, несколько МБ) вы можете прослушивать dataсобытия на стандартном выводе. Посмотрите в документах, но это должно быть что-то вроде childProc.stdout.on("data", fn).
hgoebl
30
const exec = require("child_process").exec
exec("ls", (error, stdout, stderr) => {
 //do whatever here
})
Бен Билер
источник
14
Пожалуйста, добавьте больше объяснений о том, как работает этот код и как он решает ответ. Помните, что StackOverflow создает архив ответов для людей, читающих это в будущем.
Аль Суигарт
4
То, что сказал Ал, - правда, но я скажу, что преимущество этого ответа состоит в том, что это намного проще, чем читать главный ответ для человека, которому нужен быстрый ответ.
29

Начиная с версии 4, наиболее близким вариантом является child_process.execSyncметод:

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

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

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

Пол Румкин
источник
Это прекрасно работает на последнем узле. child_processСоздано ли существо при использовании execSyncхотя? И удаляется ли он сразу после команды, верно? Так нет утечек памяти?
NiCk Newman
1
Да, нет утечек памяти. Я предполагаю, что он инициализирует только дочерние структуры процесса libuv, не создавая его вообще в узле.
Пол Румкин
21

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

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

var options = {
  encoding: 'utf8'
};

console.log(execSync(cmd, options));
Cameron
источник
14

Я только что написал помощник 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. ---------------');
    });
Vadorequest
источник
1
Самая последняя версия с примером использования Grunt в CLI: gist.github.com/Vadorequest/f72fa1c152ec55357839
Vadorequest
6

Если вы не против зависимости и хотите использовать обещания, child-process-promiseработает:

установка

npm install child-process-promise --save

Exec Usage

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);
    });
Слова, подобные Джареду
источник
6

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

var shell = require('shelljs');

shell.echo('hello world');
shell.exec('node --version')
FACEPALM
источник
Не должно быть необходимости устанавливать новые модули
Бен Билер
4

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

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

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

const system = require('system-commands')

Запустите такие команды:

system('ls').then(output => {
    console.log(output)
}).catch(error => {
    console.error(error)
})
Кен Мюллер
источник
Отлично! Прекрасно работает для моих нужд.
Рузвельт
3

Ответ @ hexacyanide почти полный. В Windows команда princeможет быть prince.exe, prince.cmd, prince.batили просто prince(я не в курсе , как драгоценные камни в комплекте, но НПЕ контейнеры поставляются с скриптом ш и пакетным сценарием - 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;
DUzun
источник