node.js menjalankan perintah sistem secara sinkron

Saya membutuhkan fungsi node.js

result = execSync('node -v');

yang secara sinkron akan mengeksekusi baris perintah yang diberikan dan mengembalikan semua stdout'ed oleh teks perintah itu.

ps. Sinkronisasi salah. Aku tahu. Hanya untuk penggunaan pribadi.

MEMPERBARUI

Sekarang kami memiliki solusi mgutz yang memberi kami kode keluar, tetapi tidak stdout! Masih menunggu jawaban yang lebih tepat.

MEMPERBARUI

mgutz memperbarui jawabannya dan solusinya ada di sini :)
Juga, seperti yang disebutkan dgo.a , ada modul yang berdiri sendiri exec-sync

UPDATE 2014-07-30

Lib ShellJS tiba. Anggap ini adalah pilihan terbaik untuk saat ini.

UPDATE 2015-02-10

AKHIRNYA! NodeJS 0.12 mendukung execSyncsecara asli.
Lihat dokumen resmi

Node.js (sejak versi 0.12 - untuk sementara waktu) mendukung execSync:

child_process.execSync(command[, options])

Anda sekarang dapat langsung melakukan ini:

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

dan itu akan melakukan apa yang Anda harapkan. (Default untuk menyalurkan hasil i / o ke proses induk). Perhatikan bahwa Anda juga bisa spawnSyncsekarang.

Lihat perpustakaan execSync .

Ini cukup mudah dilakukan dengan node-ffi . Saya tidak akan merekomendasikan untuk proses server, tetapi untuk pengembangan umum utilitas itu menyelesaikan sesuatu. Instal perpustakaan.

npm install node-ffi

Skrip contoh:

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

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

[EDIT Jun 2012: Cara mendapatkan 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'));

Gunakan ShellJS modul .

eksekutiffungsi tanpa memberikan panggilan balik.

Contoh:

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

Ada modul yang sangat baik untuk kontrol aliran di node.js yang disebut asyncblock . Jika membungkus kode dalam suatu fungsi OK untuk kasus Anda, sampel berikut dapat dipertimbangkan:

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

Ini tidak mungkin di Node.js, keduanya child_process.spawndanchild_process.exec dibangun dari bawah ke atas menjadi async.

Untuk detailnya lihat: https://github.com/ry/node/blob/master/lib/child_process.js

Jika Anda benar-benar ingin memiliki pemblokiran ini, maka letakkan semua yang perlu terjadi setelah itu dalam panggilan balik, atau buat antrean Anda sendiri untuk menangani hal ini dengan cara pemblokiran, saya kira Anda bisa menggunakan Async.js untuk tugas ini.

Atau, jika Anda memiliki terlalu banyak waktu untuk dihabiskan, coba-coba Node.js sendiri.

Ini adalah cara termudah yang saya temukan:

exec-Sync : https://github.com/jeremyfa/node-exec-sync
(Jangan bingung dengan execSync.)
Jalankan perintah shell secara sinkron. Gunakan ini untuk skrip migrasi, program cli, tetapi tidak untuk kode server biasa.

Contoh:

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

Hanya untuk menambahkan bahwa meskipun ada beberapa usecases di mana Anda harus menggunakannya, spawnSync/ execFileSync/ execSyncditambahkan ke node.js dalam komit ini: https://github.com/joyent/node/compare/d58c206862dc...e8df2676748e

Anda dapat mencapai ini menggunakan serat. Misalnya, menggunakan perpustakaan Common Node saya , kode akan terlihat seperti ini:

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

Saya terbiasa menerapkan "synchronous"hal-hal di akhir fungsi panggilan balik. Tidak terlalu bagus, tetapi berhasil. Jika Anda perlu mengimplementasikan urutan eksekusi baris perintah, Anda perlu membungkusnya execdengan beberapa fungsi bernama dan memanggilnya secara rekursif. Pola ini tampaknya dapat digunakan untuk saya:

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

Saya memiliki masalah yang sama dan akhirnya saya menulis ekstensi node untuk ini. Anda dapat memeriksa repositori git. Ini open source dan gratis dan semuanya bagus!

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

ExecXI adalah ekstensi node yang ditulis dalam C ++ untuk mengeksekusi perintah shell satu per satu, mengeluarkan output perintah ke konsol secara real-time. Tersedia pilihan cara berantai, dan tidak berantai; artinya Anda dapat memilih untuk menghentikan skrip setelah perintah gagal (dirantai), atau Anda dapat melanjutkan seolah-olah tidak ada yang terjadi!

Instruksi penggunaan ada di file ReadMe . Jangan ragu untuk melakukan permintaan tarik atau mengirim masalah!

EDIT: Namun itu belum mengembalikan stdout ... Hanya keluaran mereka secara real-time. Itu sekarang. Yah, saya baru saja merilisnya hari ini. Mungkin kita bisa membangunnya.

Bagaimanapun, saya pikir itu layak untuk disebutkan.

Anda dapat melakukan operasi shell sinkron di nodejs seperti:

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 - contoh ini dimaksudkan untuk lingkungan windows, sesuaikan dengan kebutuhan linux Anda sendiri jika perlu

Saya sebenarnya memiliki situasi di mana saya perlu menjalankan beberapa perintah satu per satu dari script package.json preinstall dengan cara yang akan bekerja pada Windows dan Linux / OSX, jadi saya tidak bisa mengandalkan modul non-inti.

Jadi inilah yang saya pikirkan:

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

Anda bisa menggunakannya seperti ini:

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

EDIT: seperti yang ditunjukkan, ini sebenarnya tidak mengembalikan output atau memungkinkan Anda untuk menggunakan hasil dari perintah dalam program Node. Satu ide lain untuk itu adalah menggunakan backcalls LiveScript. http://livescript.net/