exécuter une ligne de commande binaire dans node/js

Question

Je suis dans le processus de transfert d'une CLI bibliothèque de Ruby sur NodeJS. Dans mon code, je l'ai exécuter plusieurs tiers binaires lorsque cela est nécessaire. Je ne suis pas sûr de la meilleure façon de réaliser ce nœud/js.

Voici un exemple dans Ruby où j'appelle princexml convertir en pdf:

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

J'ai besoin de faire la même chose node/js.

Answer 1

Vous devriez jeter un oeil à la documentation. Pour exécuter une commande et récupérer sa sortie comme un tampon, utilisez child_process.exec:

var exec = require('child_process').exec;
exec('prince -v builds/pdf/book.html -o builds/pdf/book.pdf', function (error, stdout, stderr) {
  // output is in stdout
});

Pour exécuter une commande et de recevoir de sortie des flots, utilisez 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 here
});

Answer 2

Vous êtes à la recherche pour child_process.exec

Voici l'exemple:

var exec = require('child_process').exec,
    child;

child = exec('cat *.js bad_file | wc -l',
  function (error, stdout, stderr) {
    console.log('stdout: ' + stdout);
    console.log('stderr: ' + stderr);
    if (error !== null) {
      console.log('exec error: ' + error);
    }
});

Answer 3

Je viens d'écrire un Cli de l'aide pour traiter avec Unix/windows facilement.

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;

});

Tapuscrit original du fichier source:

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

}

Exemple d'utilisation:

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