node.js exécute la commande système de manière synchrone

J'ai besoin de la fonction node.js

result = execSync('node -v');

qui exécutera de manière synchrone la ligne de commande donnée et retournera tous les stdout'ed par ce texte de commande.

ps. La synchronisation est incorrecte. Je connais. Juste pour un usage personnel.

METTRE À JOUR

Nous avons maintenant la solution de mgutz qui nous donne le code de sortie, mais pas stdout! En attente d'une réponse plus précise.

METTRE À JOUR

mgutz a mis à jour sa réponse et la solution est ici :)
De plus, comme dgo.a l'a mentionné, il existe un module autonome exec-sync

MISE À JOUR 30/07/2014

La librairie ShellJS est arrivée. Considérez que c'est le meilleur choix pour le moment.

MISE À JOUR 10/02/2015

ENFIN! NodeJS 0.12 prend execSyncen charge nativement.
Voir la documentation officielle

Node.js (depuis la version 0.12 - donc pendant un certain temps) prend en charge execSync:

child_process.execSync(command[, options])

Vous pouvez maintenant le faire directement:

const execSync = require('child_process').execSync;
code = execSync('node -v');

et il fera ce que vous attendez. (Par défaut pour diriger les résultats d'E / S vers le processus parent). Notez que vous pouvez également spawnSyncmaintenant.

Voir la bibliothèque execSync .

C'est assez facile à faire avec node-ffi . Je ne recommanderais pas les processus de serveur, mais pour les utilitaires de développement généraux, cela fait avancer les choses. Installez la bibliothèque.

npm install node-ffi

Exemple de script:

var FFI = require("node-ffi");
var libc = new FFI.Library(null, {
  "system": ["int32", ["string"]]
});

var run = libc.system;
run("echo $USER");

[EDIT Jun 2012: Comment obtenir STDOUT]

var lib = ffi.Library(null, {
    // FILE* popen(char* cmd, char* mode);
    popen: ['pointer', ['string', 'string']],

    // void pclose(FILE* fp);
    pclose: ['void', [ 'pointer']],

    // char* fgets(char* buff, int buff, in)
    fgets: ['string', ['string', 'int','pointer']]
});

function execSync(cmd) {
  var
    buffer = new Buffer(1024),
    result = "",
    fp = lib.popen(cmd, 'r');

  if (!fp) throw new Error('execSync error: '+cmd);

  while(lib.fgets(buffer, 1024, fp)) {
    result += buffer.readCString();
  };
  lib.pclose(fp);

  return result;
}

console.log(execSync('echo $HOME'));

Utilisez le module ShellJS .

exec fonction sans fournir de rappel.

Exemple:

var version = exec('node -v').output;

Il existe un excellent module de contrôle de flux dans node.js appelé asyncblock . Si l'encapsulation du code dans une fonction convient à votre cas, l'exemple suivant peut être envisagé:

var asyncblock = require('asyncblock');
var exec = require('child_process').exec;

asyncblock(function (flow) {
    exec('node -v', flow.add());
    result = flow.wait();
    console.log(result);    // There'll be trailing \n in the output

    // Some other jobs
    console.log('More results like if it were sync...');
});

Cela n'est pas possible dans Node.js, à la fois child_process.spawnetchild_process.exec ont été construits à partir de zéro pour être asynchrones.

Pour plus de détails, voir: https://github.com/ry/node/blob/master/lib/child_process.js

Si vous voulez vraiment avoir ce blocage, mettez tout ce qui doit se passer par la suite dans un rappel, ou créez votre propre file d'attente pour gérer cela de manière bloquante, je suppose que vous pouvez utiliser Async.js pour cette tâche.

Ou, au cas où vous auriez beaucoup trop de temps à passer, piratez vous-même dans Node.js.

C'est le moyen le plus simple que j'ai trouvé:

exec-Sync : https://github.com/jeremyfa/node-exec-sync
(à ne pas confondre avec execSync.)
Exécutez la commande shell de manière synchrone. Utilisez-le pour les scripts de migration, les programmes cli, mais pas pour le code serveur normal.

Exemple:

var execSync = require('exec-sync');   
var user = execSync('echo $USER');
console.log(user);

Juste pour ajouter que même s'il y a peu de cas d'utilisation où vous devriez les utiliser, spawnSync/ execFileSync/ execSyncont été ajoutés à node.js dans ces commits: https://github.com/joyent/node/compare/d58c206862dc...e8df2676748e

Vous pouvez y parvenir en utilisant des fibres. Par exemple, en utilisant ma bibliothèque Common Node , le code ressemblerait à ceci:

result = require('subprocess').command('node -v');

Je m'habitue à implémenter des "synchronous"trucs à la fin de la fonction de rappel. Pas très sympa, mais ça marche. Si vous avez besoin d'implémenter une séquence d'exécutions de ligne de commande, vous devez encapsuler execdans une fonction nommée et l'appeler récursivement. Ce modèle me semble utilisable:

SeqOfExec(someParam);

function SeqOfExec(somepParam) {
    // some stuff
    // .....
    // .....

    var execStr = "yourExecString";
    child_proc.exec(execStr, function (error, stdout, stderr) {
        if (error != null) {
            if (stdout) {
                throw Error("Smth goes wrong" + error);
            } else {
                // consider that empty stdout causes
                // creation of error object
            }
        }
        // some stuff
        // .....
        // .....

        // you also need some flag which will signal that you 
        // need to end loop
        if (someFlag ) {
            // your synch stuff after all execs
            // here
            // .....
        } else {
            SeqOfExec(someAnotherParam);
        }
    });
};

J'ai eu un problème similaire et j'ai fini par écrire une extension de nœud pour cela. Vous pouvez extraire le référentiel git. C'est open source et gratuit et toutes ces bonnes choses!

https://github.com/aponxi/npm-execxi

ExecXI est une extension de nœud écrite en C ++ pour exécuter les commandes shell une par une, en envoyant la sortie de la commande à la console en temps réel. Des voies optionnelles chaînées et non chaînées sont présentes; ce qui signifie que vous pouvez choisir d'arrêter le script après l'échec d'une commande (chaînée), ou vous pouvez continuer comme si de rien n'était!

Les instructions d'utilisation se trouvent dans le fichier ReadMe . N'hésitez pas à faire des pull requests ou à soumettre des problèmes!

EDIT: Cependant, il ne renvoie pas encore le stdout ... Il suffit de les sortir en temps réel. C'est le cas maintenant.Eh bien, je viens de le publier aujourd'hui. Peut-être pouvons-nous bâtir dessus.

Quoi qu'il en soit, j'ai pensé qu'il valait la peine de le mentionner.

vous pouvez faire des opérations shell synchrones dans nodejs comme ceci:

var execSync = function(cmd) {

    var exec  = require('child_process').exec;
    var fs = require('fs');

    //for linux use ; instead of &&
    //execute your command followed by a simple echo 
    //to file to indicate process is finished
    exec(cmd + " > c:\\stdout.txt && echo done > c:\\sync.txt");

    while (true) {
        //consider a timeout option to prevent infinite loop
        //NOTE: this will max out your cpu too!
        try {
            var status = fs.readFileSync('c:\\sync.txt', 'utf8');

            if (status.trim() == "done") {
                var res = fs.readFileSync("c:\\stdout.txt", 'utf8');
                fs.unlinkSync("c:\\stdout.txt"); //cleanup temp files
                fs.unlinkSync("c:\\sync.txt");
                return res;
            }
        } catch(e) { } //readFileSync will fail until file exists
    }

};

//won't return anything, but will take 10 seconds to run
console.log(execSync("sleep 10")); 

//assuming there are a lot of files and subdirectories, 
//this too may take a while, use your own applicable file path
console.log(execSync("dir /s c:\\usr\\docs\\"));

EDIT - cet exemple est destiné aux environnements Windows, ajustez-les pour vos propres besoins Linux si nécessaire

En fait, j'ai eu une situation où je devais exécuter plusieurs commandes l'une après l'autre à partir d'un script de préinstallation package.json d'une manière qui fonctionnerait à la fois sur Windows et Linux / OSX, donc je ne pouvais pas compter sur un module non-core.

Voici donc ce que j'ai proposé:

#cmds.coffee
childproc = require 'child_process'

exports.exec = (cmds) ->
  next = ->
    if cmds.length > 0
      cmd = cmds.shift()
      console.log "Running command: #{cmd}"
      childproc.exec cmd, (err, stdout, stderr) ->
        if err? then console.log err
        if stdout? then console.log stdout
        if stderr? then console.log stderr
        next()
    else
      console.log "Done executing commands."

  console.log "Running the follows commands:"
  console.log cmds
  next()

Vous pouvez l'utiliser comme ceci:

require('./cmds').exec ['grunt coffee', 'nodeunit test/tls-config.js']

EDIT: comme indiqué, cela ne renvoie pas réellement la sortie ou ne vous permet pas d'utiliser le résultat des commandes dans un programme Node. Une autre idée pour cela est d'utiliser des backcalls LiveScript. http://livescript.net/