Exec: wyświetl standardowe wyjście „na żywo”

Mam ten prosty skrypt:

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

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

gdzie po prostu wykonuję polecenie skompilowania pliku skryptu kawy. Ale standardowe wyjście nigdy nie jest wyświetlane w konsoli, ponieważ polecenie nigdy się nie kończy (z powodu opcji -w kawy). Jeśli wykonam polecenie bezpośrednio z konsoli, otrzymam następujący komunikat:

18:05:59 - compiled my_file.coffee

Moje pytanie brzmi: czy możliwe jest wyświetlanie tych komunikatów za pomocą exec node.js? Jeśli tak jak? !

Dzięki

Nie używać exec. Użyj, spawnktóry jest EventEmmiterprzedmiotem. Następnie możesz słuchać stdout/ stderrevents ( spawn.stdout.on('data',callback..)), gdy się zdarzają .

Z dokumentacji 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 buforuje dane wyjściowe i zwykle zwraca je po zakończeniu wykonywania polecenia.

exec zwróci również obiekt ChildProcess, który jest EventEmitter.

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

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

LUB pipestdout procesu potomnego do stdout głównego.

coffeeProcess.stdout.pipe(process.stdout);

LUB odziedzicz stdio za pomocą spawn

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

Istnieje już kilka odpowiedzi, jednak żadna z nich nie wspomina o najlepszym (i najłatwiejszym) sposobie zrobienia tego, który jest przy użyciu spawni { stdio: 'inherit' }opcji . Wydaje się, że daje najdokładniejsze wyjście, na przykład podczas wyświetlania informacji o postępie z git clone.

Po prostu zrób to:

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

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

Podziękowania dla @MorganTouvereyQuilling za wskazanie tego w tym komentarzu .

Chciałbym tylko dodać, że jednym małym problemem z wyprowadzaniem ciągów buforów z odrodzonego procesu console.log()jest to, że dodaje on nowe linie, które mogą rozłożyć wyniki odrodzonego procesu na dodatkowe linie. Jeśli wyjście stdoutlub stderrze process.stdout.write()zamiast console.log()Pokochasz więc uzyskać wyjścia konsoli z zrodził proces „jak jest”.

Widziałem to rozwiązanie tutaj: Node.js: drukowanie na konsoli bez końca nowej linii?

Mam nadzieję, że pomoże to komuś, kto użyje powyższego rozwiązania (które świetnie nadaje się do transmisji na żywo, nawet jeśli pochodzi z dokumentacji).

Zainspirowany odpowiedzią Nathanael Smith i komentarzem Erica Freese'a może być tak prosty, jak:

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

Przydało mi się dodanie niestandardowego skryptu exec do moich narzędzi, które to robią.

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

Po przejrzeniu wszystkich pozostałych odpowiedzi otrzymałem:

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

Czasami databędzie wiele linii, więc oldSchoolMakeBuildnagłówek pojawi się raz dla wielu linii. Ale to mi nie przeszkadzało, żeby to zmienić.

child_process.spawn zwraca obiekt ze strumieniami stdout i stderr. Możesz dotknąć strumienia standardowego, aby odczytać dane, które proces potomny odsyła z powrotem do Węzła. stdout będący strumieniem ma „dane”, „koniec” i inne zdarzenia, które mają strumienie. spawn najlepiej przydaje się, gdy chcesz, aby proces potomny zwrócił dużą ilość danych do węzła - przetwarzanie obrazu, odczyt danych binarnych itp.

abyś mógł rozwiązać swój problem za pomocą child_process.spawn, jak opisano poniżej.

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

Oto asynchroniczna funkcja pomocnicza napisana w pismach maszynowych, która wydaje mi się wystarczająca. Myślę, że to nie zadziała w przypadku długotrwałych procesów, ale nadal może być przydatne dla kogoś?

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