node.js, sistem komutunu eşzamanlı olarak yürütür

Node.js işlevine ihtiyacım var

result = execSync('node -v');

o olacak eşzamanlı verilen komut satırını yürütmek ve bu komut metni bütün stdout'ed döner.

ps. Senkronizasyon yanlış. Biliyorum. Sadece kişisel kullanım içindir.

GÜNCELLEME

Şimdi mgutz'un çıkış kodunu veren bir çözümümüz var ama stdout değil! Hala daha kesin bir cevap bekliyorum.

GÜNCELLEME

mgutz cevabını güncelledi ve çözüm burada :)
Ayrıca, dgo.a'nın da belirttiği gibi, bağımsız modül exec-sync var

GÜNCELLEME 2014-07-30

ShellJS lib geldi. Bunun şimdilik en iyi seçim olduğunu düşünün.

GÜNCELLEME 2015-02-10

SONUNDA! NodeJS 0.12 execSyncyerel olarak desteklenir .
Resmi dokümanlara bakın

Node.js (0.12 sürümünden beri - bir süreliğine) execSyncşunları destekler :

child_process.execSync(command[, options])

Şimdi doğrudan bunu yapabilirsiniz:

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

ve beklediğinizi yapacak. (I / o sonuçlarını üst sürece aktarma varsayılanlarıdır). spawnSyncŞimdi de yapabileceğinizi unutmayın .

ExecSync kütüphanesine bakın .

Düğüm-ffi ile yapmak oldukça kolaydır . Sunucu işlemleri için tavsiye etmem, ancak genel geliştirme programları için işleri halleder. Kütüphaneyi kurun.

npm install node-ffi

Örnek komut dosyası:

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

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

[Haziran 2012 EDIT: STDOUT nasıl alınır]

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

ShellJS modülünü kullanın .

geri arama sağlamadan exec fonksiyonu.

Misal:

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

Denilen node.js akış kontrolü için mükemmel bir modül var asyncblock . Kodu bir işleve sarmak sizin durumunuz için uygunsa, aşağıdaki örnek düşünülebilir:

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

Bu node.js mümkün değildir, hem child_process.spawnve child_process.execzaman uyumsuz olması sıfırdan inşa edildi.

Ayrıntılar için bkz. Https://github.com/ry/node/blob/master/lib/child_process.js

Bu engellemeyi gerçekten yapmak istiyorsanız, daha sonra olması gereken her şeyi geri aramaya koyun veya bunu engelleme tarzında ele almak için kendi kuyruğunuzu oluşturun, sanırım bu görev için Async.js'yi kullanabilirsiniz .

Ya da, harcamak için çok fazla zamanınız varsa, Node.js'de kendiniz hackleyin.

Bulduğum en kolay yol:

exec-Sync : https://github.com/jeremyfa/node-exec-sync
(execSync ile karıştırılmamalıdır.)
Kabuk komutunu eşzamanlı olarak yürütür . Geçiş komut dosyaları, cli programları için kullanın, ancak normal sunucu kodu için kullanmayın.

Misal:

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

Bunları kullanmanız gereken az sayıda kullanıcı olsa da, spawnSync/ execFileSync/ execSyncbu işlemlerde node.js'ye eklendi: https://github.com/joyent/node/compare/d58c206862dc...e8df2676748e

Bunu elyaf kullanarak yapabilirsiniz. Örneğin, Ortak Düğüm kitaplığımı kullanarak kod şöyle görünecektir:

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

"synchronous"Geri arama işlevinin sonunda bir şeyler uygulamaya alıştım. Çok hoş değil, ama işe yarıyor. Bir dizi komut satırı yürütmesi gerçekleştirmeniz gerekiyorsa, execadlandırılmış bazı işlevlere sarmanız ve yinelemeli olarak çağırmanız gerekir. Bu model benim için kullanılabilir gibi görünüyor:

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

Benzer bir sorun yaşadım ve bunun için bir düğüm uzantısı yazdım. Git deposunu kontrol edebilirsiniz. Açık kaynak kodlu ve ücretsiz ve tüm bu iyi şeyler!

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

ExecXI, kabuk komutlarını tek tek yürütmek ve komutun çıktısını konsola gerçek zamanlı olarak göndermek için C ++ ile yazılmış bir düğüm uzantısıdır. İsteğe bağlı zincirleme ve zincirsiz yollar mevcuttur; yani komut başarısız olduğunda (zincirleme) komut dosyasını durdurmayı seçebilir veya hiçbir şey olmamış gibi devam edebilirsiniz!

Kullanım talimatları Benioku dosyasındadır . Çekme taleplerinde bulunmaktan veya sorun göndermekten çekinmeyin!

EDIT: Ancak henüz stdout dönmüyor ... Sadece gerçek zamanlı çıktılar. Şimdi öyle. Bugün yeni yayınladım. Belki bunun üzerine inşa edebiliriz.

Her neyse, bahsetmeye değer olduğunu düşündüm.

nodejs'de senkron kabuk işlemlerini şu şekilde yapabilirsiniz:

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 - bu örnek Windows ortamları içindir, gerekirse kendi linux ihtiyaçlarınız için ayarlayın

Aslında bir paketten birbiri ardına birden fazla komut çalıştırmam gereken bir durum vardı.

Ben de bu yüzden geldim:

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

Bu şekilde kullanabilirsiniz:

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

EDIT: belirtildiği gibi, bu aslında çıktıyı döndürmez veya bir Düğüm programındaki komutların sonucunu kullanmanıza izin vermez. Bunun bir diğer fikri LiveScript geri çağrılarını kullanmaktır. http://livescript.net/