node.js executa o comando do sistema de forma síncrona

Eu preciso na função node.js

result = execSync('node -v');

que executará de forma síncrona a linha de comando especificada e retornará todos os valores padrão desse texto de comando.

ps. A sincronização está errada. Eu sei. Apenas para uso pessoal.

ATUALIZAR

Agora temos a solução do mgutz, que nos dá o código de saída, mas não o stdout! Ainda esperando por uma resposta mais precisa.

ATUALIZAR

mgutz atualizou sua resposta e a solução está aqui :)
Além disso, como dgo.a mencionado, há um módulo autônomo exec-sync

ATUALIZAÇÃO 30-07-2014

A lib do ShellJS chegou. Considere que esta é a melhor escolha por enquanto.

ATUALIZAÇÃO 10-02-2015

FINALMENTE! O NodeJS 0.12 suporta execSyncnativamente.
Veja documentos oficiais

O Node.js (desde a versão 0.12 - por um tempo) suporta execSync:

child_process.execSync(command[, options])

Agora você pode fazer isso diretamente:

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

e fará o que você espera. (O padrão é canalizar os resultados de E / S para o processo pai). Observe que você também pode spawnSyncagora.

Veja a biblioteca execSync .

É bastante fácil fazer isso com o node-ffi . Eu não recomendaria para processos de servidor, mas para utilitários de desenvolvimento geral, isso é feito. Instale a biblioteca.

npm install node-ffi

Script de exemplo:

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

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

[EDIT junho 2012: como obter 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'));

Use o módulo ShellJS .

função exec sem fornecer retorno de chamada.

Exemplo:

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

Existe um excelente módulo para controle de fluxo no node.js chamado asyncblock . Se a quebra do código em uma função for boa para o seu caso, o seguinte exemplo pode ser considerado:

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

Isso não é possível no Node.js, ambos child_process.spawnechild_process.exec foram criados a partir do zero para serem assíncronos.

Para detalhes, consulte: https://github.com/ry/node/blob/master/lib/child_process.js

Se você realmente deseja ter esse bloqueio, coloque tudo o que precisa acontecer posteriormente em um retorno de chamada ou crie sua própria fila para lidar com isso de maneira bloqueadora, suponho que você possa usar o Async.js para esta tarefa.

Ou, caso você tenha muito tempo para gastar, entre no Node.js por conta própria.

Esta é a maneira mais fácil que encontrei:

exec-Sync : https://github.com/jeremyfa/node-exec-sync
(Não confunda com execSync.)
Execute o comando shell de forma síncrona. Use isso para scripts de migração, programas cli, mas não para código de servidor comum.

Exemplo:

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

Apenas para adicionar que, embora existam poucos casos de uso em que você deve usá-los, spawnSync/ execFileSync/ execSyncforam adicionados ao node.js nesses commits: https://github.com/joyent/node/compare/d58c206862dc...e8df2676748e

Você pode conseguir isso usando fibras. Por exemplo, usando minha biblioteca Common Node , o código ficaria assim:

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

Eu me acostumei a implementar "synchronous"coisas no final da função de retorno de chamada. Não é muito bom, mas funciona. Se você precisar implementar uma sequência de execuções de linha de comando, precisará envolver execem alguma função nomeada e chamá-la recursivamente. Esse padrão parece ser útil para mim:

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

Eu tive um problema semelhante e acabei escrevendo uma extensão de nó para isso. Você pode conferir o repositório git. É de código aberto, gratuito e todas essas coisas boas!

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

ExecXI é uma extensão de nó escrita em C ++ para executar comandos do shell um por um, produzindo a saída do comando no console em tempo real. Maneiras encadeadas e desencadeadas opcionais estão presentes; o que significa que você pode optar por parar o script após a falha de um comando (encadeado) ou continuar como se nada tivesse acontecido!

As instruções de uso estão no arquivo Leia-me . Sinta-se livre para fazer solicitações pull ou enviar problemas!

EDIT: No entanto, ele ainda não retorna o stdout ... Apenas gera em tempo real. Faz agora.Acabei de lançar hoje. Talvez possamos construir sobre isso.

Enfim, achei que valeria a pena mencionar.

você pode executar operações shell síncronas no nodejs da seguinte maneira:

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 - este exemplo é para ambientes Windows, ajuste para suas próprias necessidades de Linux, se necessário

Na verdade, tive uma situação em que precisava executar vários comandos um após o outro a partir de um script de pré-instalação package.json de uma maneira que funcionasse no Windows e Linux / OSX, por isso não podia confiar em um módulo não essencial.

Então é isso que eu criei:

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

Você pode usá-lo assim:

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

EDIT: como indicado, isso realmente não retorna a saída ou permite que você use o resultado dos comandos em um programa Node. Uma outra idéia para isso é usar backcalls do LiveScript. http://livescript.net/