Exec: exibe stdout “ao vivo”

Eu tenho esse script simples:

var exec = require('child_process').exec;

exec('coffee -cw my_file.coffee', function(error, stdout, stderr) {
    console.log(stdout);
});

onde simplesmente executo um comando para compilar um arquivo de script de café. Mas o stdout nunca é exibido no console, porque o comando nunca termina (por causa da opção -w do café). Se eu executar o comando diretamente do console, recebo uma mensagem como esta:

18:05:59 - compiled my_file.coffee

Minha pergunta é: é possível exibir essas mensagens com o node.js exec? Se sim, como? !

obrigado

Não use exec. Use spawnqual é um EventEmmiterobjeto. Então você pode ouvir stdout/ stderrevents ( spawn.stdout.on('data',callback..)) conforme eles acontecem .

Da documentação do NodeJS:

var spawn = require('child_process').spawn,
    ls    = spawn('ls', ['-lh', '/usr']);

ls.stdout.on('data', function (data) {
  console.log('stdout: ' + data.toString());
});

ls.stderr.on('data', function (data) {
  console.log('stderr: ' + data.toString());
});

ls.on('exit', function (code) {
  console.log('child process exited with code ' + code.toString());
});

exec armazena em buffer a saída e geralmente a retorna quando o comando termina de executar.

exec também retornará um objeto ChildProcess que é um EventEmitter.

var exec = require('child_process').exec;
var coffeeProcess = exec('coffee -cw my_file.coffee');

coffeeProcess.stdout.on('data', function(data) {
    console.log(data); 
});

OU pipeo stdout do processo filho para o stdout principal.

coffeeProcess.stdout.pipe(process.stdout);

OU herdar stdio usando spawn

spawn('coffee -cw my_file.coffee', { stdio: 'inherit' });

Já existem várias respostas, no entanto, nenhuma delas menciona a melhor (e mais fácil) maneira de fazer isso, que está usando spawne a { stdio: 'inherit' }opção . Parece produzir a saída mais precisa, por exemplo, ao exibir as informações de progresso de umgit clone .

Simplesmente faça o seguinte:

var spawn = require('child_process').spawn;

spawn('coffee', ['-cw', 'my_file.coffee'], { stdio: 'inherit' });

Os nossos agradecimentos a @MorganTouvereyQuilling por apontar isso neste comentário .

Gostaria apenas de acrescentar que um pequeno problema com a saída das seqüências de buffer de um processo gerado console.log()é que ela adiciona novas linhas, que podem espalhar a saída do processo gerado por linhas adicionais. Se você imprimir stdoutou stderrcom em process.stdout.write()vez deconsole.log() , obterá a saída do console do processo gerado 'como está'.

Eu vi essa solução aqui: Node.js: imprimindo no console sem uma nova linha à direita?

Espero que ajude alguém a usar a solução acima (que é ótima para saída ao vivo, mesmo que seja da documentação).

Inspirado na resposta de Nathanael Smith e no comentário de Eric Freese, pode ser tão simples quanto:

var exec = require('child_process').exec;
exec('coffee -cw my_file.coffee').stdout.pipe(process.stdout);

Eu achei útil adicionar um script exec personalizado aos meus utilitários que fazem isso.

utilities.js

const { exec } = require('child_process')

module.exports.exec = (command) => {
  const process = exec(command)

  process.stdout.on('data', (data) => {
    console.log('stdout: ' + data.toString())
  })

  process.stderr.on('data', (data) => {
    console.log('stderr: ' + data.toString())
  })

  process.on('exit', (code) => {
    console.log('child process exited with code ' + code.toString())
  })
}

app.js

const { exec } = require('./utilities.js')

exec('coffee -cw my_file.coffee')

Depois de revisar todas as outras respostas, acabei com isso:

function oldSchoolMakeBuild(cb) {
    var makeProcess = exec('make -C ./oldSchoolMakeBuild',
         function (error, stdout, stderr) {
             stderr && console.error(stderr);
             cb(error);
        });
    makeProcess.stdout.on('data', function(data) {
        process.stdout.write('oldSchoolMakeBuild: '+ data);
    });
}

Às vezes, datahaverá várias linhas, portanto o oldSchoolMakeBuildcabeçalho aparecerá uma vez para várias linhas. Mas isso não me incomodou o suficiente para mudar isso.

child_process.spawn retorna um objeto com os fluxos stdout e stderr. Você pode tocar no fluxo stdout para ler os dados que o processo filho envia de volta ao Nó. stdout sendo um fluxo possui os "dados", "fim" e outros eventos que os fluxos têm. o spawn é melhor usado quando você deseja que o processo filho retorne uma grande quantidade de dados ao Nó - processamento de imagem, leitura de dados binários etc.

para que você possa resolver seu problema usando child_process.spawn, conforme usado abaixo.

var spawn = require('child_process').spawn,
ls = spawn('coffee -cw my_file.coffee');

ls.stdout.on('data', function (data) {
  console.log('stdout: ' + data.toString());
});

ls.stderr.on('data', function (data) {
  console.log('stderr: ' + data.toString());
});

ls.on('exit', function (code) {
  console.log('code ' + code.toString());
});

Aqui está uma função auxiliar assíncrona escrita em texto datilografado que parece fazer o truque para mim. Eu acho que isso não vai funcionar para processos de longa duração, mas ainda pode ser útil para alguém?

import * as child_process from "child_process";

private async spawn(command: string, args: string[]): Promise<{code: number | null, result: string}> {
    return new Promise((resolve, reject) => {
        const spawn = child_process.spawn(command, args)
        let result: string
        spawn.stdout.on('data', (data: any) => {
            if (result) {
                reject(Error('Helper function does not work for long lived proccess'))
            }
            result = data.toString()
        })
        spawn.stderr.on('data', (error: any) => {
            reject(Error(error.toString()))
        })
        spawn.on('exit', code => {
            resolve({code, result})
        })
    })
}