node.js esegue il comando di sistema in modo sincrono

Ho bisogno della funzione node.js

result = execSync('node -v');

che eseguirà in modo sincrono la riga di comando indicata e restituirà tutto stdout'ed da quel testo di comando.

ps. La sincronizzazione è sbagliata. Lo so. Solo per uso personale.

AGGIORNARE

Ora abbiamo la soluzione di mgutz che ci dà il codice di uscita, ma non stdout! Sto ancora aspettando una risposta più precisa.

AGGIORNARE

mgutz ha aggiornato la sua risposta e la soluzione è qui :)
Inoltre, come menzionato dgo.a , c'è un modulo stand-alone exec-sync

AGGIORNAMENTO 2014-07-30

La libreria ShellJS è arrivata. Considera questa è la scelta migliore per ora.

AGGIORNAMENTO 2015-02-10

ALLA FINE! NodeJS 0.12 supporta execSyncnativamente.
Vedi documenti ufficiali

Node.js (dalla versione 0.12, quindi per un po ') supporta execSync:

child_process.execSync(command[, options])

Ora puoi farlo direttamente:

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

e farà quello che ti aspetti. (L'impostazione predefinita è convogliare i risultati di I / O al processo padre). Nota che puoi anche spawnSyncadesso.

Vedi la libreria execSync .

È abbastanza facile da fare con node-ffi . Non consiglierei per i processi del server, ma per le utility di sviluppo generali fa le cose. Installa la libreria.

npm install node-ffi

Script di esempio:

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

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

[MODIFICA giugno 2012: come ottenere 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'));

Usa il modulo ShellJS .

funzione exec senza fornire callback.

Esempio:

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

Esiste un modulo eccellente per il controllo del flusso in node.js chiamato asyncblock . Se il wrapping del codice in una funzione è corretto per il tuo caso, è possibile prendere in considerazione il seguente esempio:

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

Questo non è possibile in Node.js, entrambi child_process.spawne child_process.execsono stati costruiti da zero per essere asincroni.

Per i dettagli, consultare: https://github.com/ry/node/blob/master/lib/child_process.js

Se vuoi davvero avere questo blocco, quindi metti tutto ciò che deve accadere in seguito in un callback o costruisci la tua coda per gestirlo in modo bloccante, suppongo che potresti usare Async.js per questo compito.

Oppure, nel caso in cui tu abbia troppo tempo da spendere, scatta da solo in Node.js.

Questo è il modo più semplice che ho trovato:

exec-Sync : https://github.com/jeremyfa/node-exec-sync
(Da non confondere con execSync.)
Eseguire il comando shell in modo sincrono. Usalo per script di migrazione, programmi cli, ma non per un normale codice server.

Esempio:

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

Solo per aggiungere che anche se ci sono poche casi d'uso in cui dovresti usarli, spawnSync/ execFileSync/ execSyncsono stati aggiunti a node.js in questi commit: https://github.com/joyent/node/compare/d58c206862dc...e8df2676748e

Puoi farlo usando le fibre. Ad esempio, usando la mia libreria Common Node , il codice sarebbe simile al seguente:

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

Mi abituo a implementare "synchronous"roba alla fine della funzione di callback. Non molto carino, ma funziona. Se è necessario implementare una sequenza di esecuzioni da riga di comando, è necessario includere execalcune funzioni denominate e chiamarle in modo ricorsivo. Questo modello sembra essere utilizzabile per me:

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

Ho avuto un problema simile e ho finito per scrivere un'estensione del nodo per questo. Puoi dare un'occhiata al repository git. È open source e gratuito e tutte quelle cose buone!

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

ExecXI è un'estensione del nodo scritta in C ++ per eseguire i comandi della shell uno alla volta, trasmettendo l'output del comando alla console in tempo reale. Sono presenti modi concatenati e non concatenati opzionali; nel senso che puoi scegliere di interrompere lo script dopo che un comando ha esito negativo (incatenato), oppure puoi continuare come se nulla fosse successo!

Le istruzioni per l'uso si trovano nel file Leggimi . Sentiti libero di fare richieste pull o inviare problemi!

EDIT: Tuttavia non restituisce ancora lo stdout ... Li emette in tempo reale. Lo fa adesso. Bene, l'ho appena rilasciato oggi. Forse possiamo costruirci sopra.

Comunque, ho pensato che valesse la pena menzionarlo.

puoi fare operazioni di shell sincrone in nodejs in questo modo:

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: questo esempio è pensato per ambienti Windows, se necessario aggiustalo per le tue esigenze di Linux

In realtà ho avuto una situazione in cui avevo bisogno di eseguire più comandi uno dopo l'altro da uno script preinstallato package.json in un modo che funzionasse su Windows e Linux / OSX, quindi non potevo fare affidamento su un modulo non core.

Quindi questo è quello che mi è venuto in mente:

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

Puoi usarlo in questo modo:

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

EDIT: come sottolineato, questo in realtà non restituisce l'output o consente di utilizzare il risultato dei comandi in un programma Node. Un'altra idea è quella di utilizzare backcalls LiveScript. http://livescript.net/