node.js synchronicznie wykonuje polecenia systemowe

Potrzebuję w funkcji node.js.

result = execSync('node -v');

która synchronicznie wykona podaną linię poleceń i zwróci wszystkie stdout'ed przez ten tekst polecenia.

ps. Synchronizacja jest nieprawidłowa. Wiem. Tylko do użytku osobistego.

AKTUALIZACJA

Teraz mamy rozwiązanie mgutz, które daje nam kod zakończenia, ale nie stdout! Wciąż czekam na dokładniejszą odpowiedź.

AKTUALIZACJA

mgutz zaktualizował swoją odpowiedź i rozwiązanie jest tutaj :)
Ponadto, jak wspomniał dgo.a , istnieje samodzielny moduł exec-sync

UPDATE 2014-07-30

Przybyła biblioteka ShellJS . Rozważ, że to najlepszy wybór na razie.

AKTUALIZACJA 10.02.2015

W KOŃCU! NodeJS 0.12 obsługuje execSyncnatywnie.
Zobacz oficjalne dokumenty

Node.js (od wersji 0.12 - czyli przez chwilę) obsługuje execSync:

child_process.execSync(command[, options])

Możesz teraz zrobić to bezpośrednio:

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

i zrobi to, czego oczekujesz. (Domyślnie potokuje wyniki wejścia / wyjścia do procesu nadrzędnego). Zauważ, że możesz spawnSyncteraz.

Zobacz bibliotekę execSync .

Dość łatwo to zrobić z node-ffi . Nie polecałbym procesów serwerowych, ale w przypadku ogólnych narzędzi programistycznych to załatwia sprawę. Zainstaluj bibliotekę.

npm install node-ffi

Przykładowy skrypt:

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

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

[EDIT Jun 2012: How to get 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'));

Użyj modułu ShellJS .

exec bez wywołania zwrotnego.

Przykład:

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

W node.js jest doskonały moduł do kontroli przepływu o nazwie asyncblock . Jeśli zawijanie kodu w funkcję jest w porządku w Twoim przypadku, można wziąć pod uwagę następujący przykład:

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

Nie jest to możliwe w Node.js, oba child_process.spawni child_process.execzostały zbudowane od podstaw, aby były asynchroniczne.

Aby uzyskać szczegółowe informacje, patrz: https://github.com/ry/node/blob/master/lib/child_process.js

Jeśli naprawdę chcesz mieć to blokowanie, umieść wszystko, co musi się wydarzyć później, w wywołaniu zwrotnym lub zbuduj własną kolejkę, aby obsłużyć to w sposób blokujący, przypuszczam, że możesz użyć Async.js do tego zadania.

Lub, jeśli masz zbyt dużo czasu do spędzenia, włamać się do Node.js samodzielnie.

To najłatwiejszy sposób, jaki znalazłem:

exec-Sync : https://github.com/jeremyfa/node-exec-sync
(nie mylić z execSync).
Wykonaj polecenie powłoki synchronicznie. Użyj tego dla skryptów migracji, programów CLI, ale nie dla zwykłego kodu serwera.

Przykład:

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

Wystarczy dodać, że chociaż jest kilka przypadków użycia, w których powinieneś ich użyć, spawnSync/ execFileSync/ execSynczostały dodane do node.js w tych zatwierdzeniach: https://github.com/joyent/node/compare/d58c206862dc...e8df2676748e

Możesz to osiągnąć za pomocą włókien. Na przykład, używając mojej biblioteki Common Node , kod wyglądałby następująco:

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

Przyzwyczajam się do implementacji "synchronous"rzeczy na końcu funkcji zwrotnej. Niezbyt ładne, ale działa. Jeśli chcesz zaimplementować sekwencję wykonań wiersza poleceń, musisz zawinąć execw jakąś nazwaną funkcję i rekurencyjnie ją wywołać. Ten wzór wydaje mi się przydatny:

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

Miałem podobny problem i napisałem do tego rozszerzenie węzła. Możesz sprawdzić repozytorium git. To open source, darmowe i wszystkie dobre rzeczy!

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

ExecXI to rozszerzenie węzła napisane w C ++ w celu wykonywania poleceń powłoki jeden po drugim, wysyłając dane wyjściowe polecenia do konsoli w czasie rzeczywistym. Obecne są opcjonalne łańcuchowe i niezwiązane sposoby; co oznacza, że ​​możesz zatrzymać skrypt po niepowodzeniu polecenia (połączonym w łańcuch) lub możesz kontynuować, jakby nic się nie stało!

Instrukcje użytkowania znajdują się w pliku ReadMe . Zapraszam do składania żądań ściągnięcia lub zgłaszania problemów!

EDYCJA: Jednak nie zwraca jeszcze standardowego wyjścia ... Po prostu wyświetla je w czasie rzeczywistym. Teraz tak. Cóż, właśnie go dzisiaj wydałem. Może możemy na tym zbudować.

Zresztą pomyślałem, że warto o tym wspomnieć.

możesz wykonywać synchroniczne operacje powłoki w nodejs w ten sposób:

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

EDYCJA - ten przykład jest przeznaczony dla środowisk Windows, w razie potrzeby dostosuj do własnych potrzeb Linuksa

W rzeczywistości miałem sytuację, w której musiałem uruchamiać wiele poleceń jedno po drugim ze skryptu preinstalacji package.json w sposób, który działałby zarówno w systemie Windows, jak i Linux / OSX, więc nie mogłem polegać na module spoza jądra.

Oto co wymyśliłem:

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

Możesz go używać w ten sposób:

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

EDYCJA: jak wskazano, w rzeczywistości nie zwraca to danych wyjściowych ani nie pozwala na użycie wyniku poleceń w programie Node. Innym pomysłem na to jest użycie wywołań zwrotnych LiveScript. http://livescript.net/