node.js führt den Systembefehl synchron aus

Ich brauche in node.js Funktion

result = execSync('node -v');

das wird synchron die gegebene Befehlszeile ausgeführt werden und kehren alle stdout'ed von diesem Befehlstext.

ps. Die Synchronisierung ist falsch. Ich weiß. Nur für den persönlichen Gebrauch.

AKTUALISIEREN

Jetzt haben wir die Lösung von mgutz, die uns den Exit-Code gibt, aber nicht stdout! Ich warte immer noch auf eine genauere Antwort.

AKTUALISIEREN

mgutz hat seine Antwort aktualisiert und die Lösung ist hier :)
Wie dgo.a bereits erwähnt hat, gibt es auch ein eigenständiges Modul exec-sync

UPDATE 30.07.2014

ShellJS lib ist angekommen. Betrachten Sie dies als die beste Wahl für den Moment.

UPDATE 10.02.2015

ZU GUTER LETZT! NodeJS 0.12 unterstützt execSyncnativ.
Siehe offizielle Dokumente

Node.js (seit Version 0.12 - also für eine Weile) unterstützt execSync:

child_process.execSync(command[, options])

Sie können dies jetzt direkt tun:

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

und es wird tun, was Sie erwarten. (Standardmäßig werden die E / A-Ergebnisse an den übergeordneten Prozess weitergeleitet.) Beachten Sie, dass Sie auch spawnSyncjetzt können.

Siehe execSync- Bibliothek.

Mit Node-ffi ist das ziemlich einfach . Ich würde es nicht für Serverprozesse empfehlen, aber für allgemeine Entwicklungsdienstprogramme werden die Dinge erledigt. Installieren Sie die Bibliothek.

npm install node-ffi

Beispielskript:

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

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

[EDIT Jun 2012: Wie bekomme ich 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'));

Verwenden Sie das ShellJS- Modul.

Exec- Funktion ohne Rückruf.

Beispiel:

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

In node.js gibt es ein hervorragendes Modul zur Flusskontrolle namens asyncblock . Wenn das Umschließen des Codes in eine Funktion für Ihren Fall in Ordnung ist, kann das folgende Beispiel in Betracht gezogen werden:

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

Dies ist in Node.js nicht möglich child_process.spawn und child_process.execwurde von Grund auf asynchron erstellt.

Für Details siehe: https://github.com/ry/node/blob/master/lib/child_process.js

Wenn Sie diese Blockierung wirklich möchten, dann setzen Sie alles, was danach passieren muss, in einen Rückruf oder erstellen Sie eine eigene Warteschlange, um dies blockierend zu behandeln. Ich nehme an, Sie könnten Async.js verwenden für diese Aufgabe verwenden.

Oder, falls Sie viel zu viel Zeit haben, hacken Sie in Node.js selbst herum.

Dies ist der einfachste Weg, den ich gefunden habe:

exec-Sync : https://github.com/jeremyfa/node-exec-sync
(Nicht zu verwechseln mit execSync.)
Shell-Befehl synchron . Verwenden Sie diese Option für Migrationsskripte und CLI-Programme, jedoch nicht für regulären Servercode.

Beispiel:

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

Nur um das hinzuzufügen, obwohl es nur wenige Anwendungsfälle gibt, in denen Sie sie verwenden sollten, wurden spawnSync/ execFileSync/ execSyncin diesen Commits zu node.js hinzugefügt: https://github.com/joyent/node/compare/d58c206862dc...e8df2676748e

Sie können dies mit Fasern erreichen. Wenn Sie beispielsweise meine Common Node-Bibliothek verwenden , sieht der Code folgendermaßen aus:

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

Ich gewöhne mich daran, "synchronous"Dinge am Ende der Rückruffunktion zu implementieren . Nicht sehr schön, aber es funktioniert. Wenn Sie eine Folge von Befehlszeilenausführungen implementieren müssen, müssen Sie execin eine benannte Funktion einbrechen und diese rekursiv aufrufen. Dieses Muster scheint für mich brauchbar zu sein:

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

Ich hatte ein ähnliches Problem und schrieb schließlich eine Knotenerweiterung dafür. Sie können das Git-Repository auschecken. Es ist Open Source und kostenlos und all das gute Zeug!

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

ExecXI ist eine in C ++ geschriebene Knotenerweiterung, mit der Shell-Befehle einzeln ausgeführt werden und die Ausgabe des Befehls in Echtzeit an die Konsole ausgegeben wird. Optional sind verkettete und nicht verkettete Wege vorhanden. Dies bedeutet, dass Sie das Skript stoppen können, nachdem ein Befehl fehlgeschlagen (verkettet) ist, oder Sie können fortfahren, als wäre nichts passiert!

Gebrauchsanweisungen finden Sie in der ReadMe-Datei . Fühlen Sie sich frei, Pull-Anfragen zu stellen oder Probleme einzureichen!

EDIT: Allerdings gibt es das stdout noch nicht zurück ... Gibt sie nur in Echtzeit aus. Das tut es jetzt.Nun, ich habe es heute gerade veröffentlicht. Vielleicht können wir darauf aufbauen.

Jedenfalls dachte ich, es lohnt sich, es zu erwähnen.

Sie können synchrone Shell-Operationen in NodeJs wie folgt ausführen:

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\\"));

BEARBEITEN - Dieses Beispiel ist für Windows-Umgebungen gedacht. Passen Sie es bei Bedarf an Ihre eigenen Linux-Anforderungen an

Ich hatte tatsächlich eine Situation, in der ich mehrere Befehle nacheinander von einem package.json-Vorinstallationsskript aus ausführen musste, so dass es sowohl unter Windows als auch unter Linux / OSX funktioniert, sodass ich mich nicht auf ein Nicht-Core-Modul verlassen konnte.

Das habe ich mir also ausgedacht:

#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()

Sie können es so verwenden:

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

BEARBEITEN: Wie bereits erwähnt, wird dadurch weder die Ausgabe zurückgegeben noch das Ergebnis der Befehle in einem Knotenprogramm verwendet. Eine andere Idee dafür ist die Verwendung von LiveScript-Backcalls. http://livescript.net/