Führen Sie ein Befehlszeilen-Binär mit Node.js aus

Question

Ich bin dabei, eine CLI-Bibliothek von Ruby auf Node.js zu portieren. In meinem Code führe ich bei Bedarf mehrere Drittanbieter-Binärdateien aus. Ich bin mir nicht sicher, wie ich dies am besten in Node erreichen kann.

Hier ist ein Beispiel in Ruby, bei dem ich PrinceXML aufrufe, um eine Datei in eine PDF umzuwandeln:

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

Was ist der entsprechende Code in Node?

Answer 1

const exec = require("child_process").exec
exec("ls", (error, stdout, stderr) => {
 //Hier irgendetwas machen
})

Answer 2

Wenn Sie etwas möchten, das dem höchstbewerteten Antwort sehr ähnelt, aber auch synchron ist, dann wird dies funktionieren.

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

var options = {
  encoding: 'utf8'
};

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

Answer 3

Ich habe gerade einen Cli-Helfer geschrieben, um Unix/Windows leicht zu behandeln.

JavaScript:

define(["require", "exports"], function (require, exports) {
    /**
     * Helfer, um die Befehlszeilenschnittstelle (CLI) einfach sowohl mit Windows als auch Unix-Umgebungen zu verwenden.
     * Erfordert underscore oder lodash als global über "_".
     */
    var Cli = (function () {
        function Cli() {}
            /**
             * Führen Sie einen CLI-Befehl aus.
             * Verwalten Sie Windows- und Unix-Umgebung und versuchen Sie, den Befehl auf beiden Umgebungen auszuführen, wenn er fehlschlägt.
             * Reihenfolge: Windows -> Unix.
             *
             * @param command                   Auszuführender Befehl. ('grunt')
             * @param args                      Argumente des Befehls. ('watch')
             * @param callback                  Erfolg.
             * @param callbackErrorWindows      Fehler in der Windows-Umgebung.
             * @param callbackErrorUnix         Fehler in der Unix-Umgebung.
             */
        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('------------- Fehler beim Ausführen des Befehls: "' + command + '" auf allen Umgebungen. -------------');
                }
            });
        };

        /**
         * Führen Sie einen Befehl in der Windows-Umgebung aus.
         *
         * @param command       Auszuführender Befehl. ('grunt')
         * @param args          Argumente des Befehls. ('watch')
         * @param callback      Erfolgsrückruf.
         * @param callbackError Fehler Rückruf.
         */
        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');
            }
        };

        /**
         * Führen Sie einen Befehl in der Unix-Umgebung aus.
         *
         * @param command       Auszuführender Befehl. ('grunt')
         * @param args          Argumente des Befehls. ('watch')
         * @param callback      Erfolgsrückruf.
         * @param callbackError Fehler Rückruf.
         */
        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');
            }
        };

        /**
         * Führen Sie unabhängig von der Umgebung einen Befehl aus.
         *
         * @param command   Auszuführender Befehl. ('grunt')
         * @param args      Argumente des Befehls. ('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;
});

Typscript Ursprungsquelle Datei:

 /**
 * Helfer, um die Befehlszeilenschnittstelle (CLI) einfach sowohl mit Windows als auch Unix-Umgebungen zu verwenden.
 * Erfordert underscore oder lodash als global über "_".
 */
export class Cli {

    /**
     * Führen Sie einen CLI-Befehl aus.
     * Verwalten Sie Windows- und Unix-Umgebung und versuchen Sie, den Befehl auf beiden Umgebungen auszuführen, wenn er fehlschlägt.
     * Reihenfolge: Windows -> Unix.
     *
     * @param command                   Auszuführender Befehl. ('grunt')
     * @param args                      Argumente des Befehls. ('watch')
     * @param callback                  Erfolg.
     * @param callbackErrorWindows      Fehler in der Windows-Umgebung.
     * @param callbackErrorUnix         Fehler in der Unix-Umgebung.
     */
    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('------------- Fehler beim Ausführen des Befehls: "' + command + '" auf allen Umgebungen. -------------');
            }
        });
    }

    /**
     * Führen Sie einen Befehl in der Windows-Umgebung aus.
     *
     * @param command       Auszuführender Befehl. ('grunt')
     * @param args          Argumente des Befehls. ('watch')
     * @param callback      Erfolgsrückruf.
     * @param callbackError Fehler Rückruf.
     */
    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');
        }
    }

    /**
     * Führen Sie einen Befehl in der Unix-Umgebung aus.
     *
     * @param command       Auszuführender Befehl. ('grunt')
     * @param args          Argumente des Befehls. ('watch')
     * @param callback      Erfolgsrückruf.
     * @param callbackError Fehler Rückruf.
     */
    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');
        }
    }

    /**
     * Führen Sie unabhängig von der Umgebung einen Befehl aus.
     *
     * @param command   Auszuführender Befehl. ('grunt')
     * @param args      Argumente des Befehls. ('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());
        });
    }
}

Beispiel der Verwendung:

    Cli.execute(Grunt._command, args, function (command, args, env) {
        console.log('Grunt wurde automatisch ausgeführt. (' + env + ')');

    }, function (command, args, env) {
        console.error('------------- Windows "' + command + '" Befehl fehlgeschlagen, versuche Unix... ---------------');

    }, function (command, args, env) {
        console.error('------------- Unix "' + command + '" Befehl ist auch fehlgeschlagen. ---------------');
    });

Answer 4

Verwenden Sie dieses leichtgewichtige npm-Paket: system-commands

Schauen Sie es sich hier an.

Importieren Sie es wie folgt:

const system = require('system-commands')

Führen Sie Befehle wie folgt aus:

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

Answer 5

Wenn Sie sich nicht an eine Abhängigkeit stören und Versprechungen verwenden möchten, funktioniert child-process-promise:

Installation

npm install child-process-promise --save

exec Verwendung

var exec = require('child-process-promise').exec;

exec('echo hallo')
    .then(function (result) {
        var stdout = result.stdout;
        var stderr = result.stderr;
        console.log('stdout: ', stdout);
        console.log('stderr: ', stderr);
    })
    .catch(function (err) {
        console.error('FEHLER: ', err);
    });

spawn Verwendung

var spawn = require('child-process-promise').spawn;

var promise = spawn('echo', ['hallo']);

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] fertig!');
    })
    .catch(function (err) {
        console.error('[spawn] FEHLER: ', err);
    });

ECMAScript Module import...from Syntax

import {exec} from 'child-process-promise';
let result = await exec('echo hi');
console.log(result.stdout);