node.js führt den Systembefehl synchron aus

Muss ich in der node.js Funktion

result = execSync('node -v');

wird synchron führen Sie die angegebene Befehlszeile und gib alle stdout ' ed indem das Befehl text.

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

UPDATE

Nun haben wir mgutz die Lösung, die uns die exit-code, aber nicht stdout! Warten immer noch auf eine genauere Antwort.

UPDATE

mgutz aktualisiert seine Antwort und die Lösung ist hier 🙂
Auch, als dgo.ein erwähnt, gibt es stand-alone-Modul exec-sync

UPDATE 2014-07-30

ShellJS lib angekommen. Betrachten Sie dies ist die beste Wahl für jetzt.

UPDATE 2015-02-10

ENDLICH! NodeJS 0.12 unterstützt execSync nativ.
Siehe offizielle docs

InformationsquelleAutor der Frage disfated | 2010-12-14

99

Node.js (seit version 0.12 - also für eine Weile) unterstützt execSync:
```
child_process.execSync(command[, options])
```
Können Sie jetzt direkt hierzu:
```
const execSync = require('child_process').execSync;
code = execSync('node -v');
```
und es werde tun, was Sie erwarten. (Standardmäßig pipe-i/o-Ergebnisse an den parent-Prozess). Beachten Sie, dass Sie auch spawnSync jetzt.

InformationsquelleAutor der Antwort Benjamin Gruenbaum

Sehen execSync Bibliothek.

Es ist ziemlich einfach zu tun mit Knoten-ffi. Ich würde nicht empfehlen für server-Prozesse, sondern auch für die Allgemeine Entwicklung Dienstprogramme, die Sie bekommt Dinge geschafft. Installieren Sie die Bibliothek.

npm install node-ffi

Beispiel-Skript:

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

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

[BEARBEITEN Jun 2012: Wie man 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'));

InformationsquelleAutor der Antwort mgutz

31

Verwenden ShellJS Modul.

exec Funktion ohne Angabe Rückruf.

Beispiel:
```
var version = exec('node -v').output;
```
InformationsquelleAutor der Antwort falko

Gibt es ein ausgezeichnetes Modul für die Ablaufsteuerung in node.js genannt asyncblock. Wenn das einwickeln der code in einer Funktion ist OK, für Ihren Fall, wird das folgende Beispiel betrachtet werden kann:

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

InformationsquelleAutor der Antwort nab

11

Ist dies nicht möglich Node.js beide child_process.spawn und child_process.exec wurden von Grund auf neu gebaut werden, async.

Einzelheiten finden Sie unter: https://github.com/ry/node/blob/master/lib/child_process.js

Wenn Sie wirklich wollen, um diese zu blockieren, dann legen Sie alles, was passieren muss, um anschließend in einem Rückruf oder bauen Sie sich Ihren eigenen queue zu behandeln, das in einer blocking-Mode, ich vermute, Sie könnte verwenden Async.js für diese Aufgabe.

Oder, im Falle Sie haben viel zu viel Zeit zu verbringen, zu hacken um in Node.js es sich von selbst.

InformationsquelleAutor der Antwort Ivo Wetzel
9

Dies ist der einfachste Weg, die ich gefunden habe:

exec-Sync:
https://github.com/jeremyfa/node-exec-sync

(Nicht zu verwechseln mit execSync.)

Ausführen von shell-Befehl synchron. Verwenden Sie diese für die migration-Skripte, cli-Programme, aber nicht für den regulären server-code.

Beispiel:
```
var execSync = require('exec-sync');   
var user = execSync('echo $USER');
console.log(user);
```
InformationsquelleAutor der Antwort
7

Nur hinzufügen, dass, obwohl gibt es nur wenige usecases, wo Sie sollten Sie verwenden, spawnSync /execFileSync /execSync wurden Hinzugefügt node.js in diesen verpflichtet: https://github.com/joyent/node/compare/d58c206862dc...e8df2676748e

InformationsquelleAutor der Antwort kvz
5

Können Sie erreichen dies mit Fasern. Zum Beispiel, mit meinem Allgemeine Knoten-Bibliothekwürde der code wie folgt Aussehen:
```
result = require('subprocess').command('node -v');
```
InformationsquelleAutor der Antwort Oleg

Bekomme ich verwendet, um zu implementieren "synchronous" Zeug am Ende der callback-Funktion. Nicht sehr schön, aber es funktioniert. Wenn Sie implementieren müssen, um eine Sequenz von Befehlszeilen-Ausführungen müssen Sie wrap exec in einigen benannten Funktion und rekursiv aufrufen.
Dieses Muster scheint brauchbar, für mich:

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

InformationsquelleAutor der Antwort scherka

3

Ich hatte ein ähnliches problem und ich landete schriftlich ein-Knoten-Erweiterung für diese. Sie können check aus dem git-repository. Es ist open source und kostenlos, und all das gute Zeug !

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

ExecXI ist ein-Knoten-Erweiterung in C++ geschrieben zum ausführen von shell-Kommandos
eins nach dem anderen, geben Sie die Ausgabe des Befehls in der Konsole
real-time. Optional verkettet und unchained Möglichkeiten vorhanden sind, das heißt,
Sie können wählen, um stoppen Sie das Skript, nachdem ein Befehl fehlschlägt
(verkettet), oder Sie können fortsetzen, als ob nichts passiert ist !

Gebrauchsanweisungen sind in der ReadMe-Datei. Fühlen Sie sich frei, pull-requests oder Probleme melden!

EDIT: ~~Allerdings spielt es keine Rückkehr der stdout noch... Nur Ausgänge in Echtzeit.~~ Sie Es jetzt tut. Gut, ich habe gerade freigegeben, es heute. Vielleicht können wir darauf aufbauen.

Sowieso, ich dachte, es war es Wert, es zu erwähnen.

InformationsquelleAutor der Antwort Logan

können Sie tun, synchron-shell-Operationen in nodejs etwa so:

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 gedacht für windows-Umgebungen passen Sie für Ihre eigenen linux braucht, wenn notwendig

InformationsquelleAutor der Antwort Marcus Pope

Eigentlich hatte ich eine situation, wo ich brauchte, um mehrere Befehle nacheinander aus einem Paket.json-preinstall-Skript in einer Weise, die funktionieren würde, ist auf Windows-und Linux/OSX, so konnte ich nicht verlassen sich auf eine non-core-Modul.

Also das ist, was ich kam mit:

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

Können Sie es verwenden, wie diese:

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

EDIT: wie hingewiesen, das es eigentlich nicht zurückgeben, die Ausgabe oder können Sie das Ergebnis der Befehle in einem Knoten-Programm. Eine andere Idee ist die Verwendung von LiveScript backcalls. http://livescript.net/

InformationsquelleAutor der Antwort Jason Livesay

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.