Я все еще пытаюсь использовать Node.js, но у меня есть несколько идей. во-первых, я считаю, что вам нужно использовать execFile вместо spawn; execFile предназначен для случаев, когда у вас есть путь к сценарию, тогда как spawn предназначен для выполнения хорошо известной команды, которую Node.js может разрешить в соответствии с вашим системным путем.

1. Обеспечьте обратный вызов для обработки буферизованного вывода:

var child = require('child_process').execFile('path/to/script', [ 
    'arg1', 'arg2', 'arg3', 
], function(err, stdout, stderr) { 
    // Node.js will invoke this callback when process terminates.
    console.log(stdout); 
});  

2. Добавьте слушателя в поток дочернего процесса (9thport.net)

var child = require('child_process').execFile('path/to/script', [ 
    'arg1', 'arg2', 'arg3' ]); 
// use event hooks to provide a callback to execute when data are available: 
child.stdout.on('data', function(data) {
    console.log(data.toString()); 
});

Кроме того, похоже, есть варианты, с помощью которых вы можете отсоединить порожденный процесс от управляющего терминала Node, что позволит ему работать асинхронно. Я еще не тестировал это, но в документах по API есть примеры нравится:

child = require('child_process').execFile('path/to/script', [ 
    'arg1', 'arg2', 'arg3', 
], { 
    // detachment and ignored stdin are the key here: 
    detached: true, 
    stdio: [ 'ignore', 1, 2 ]
}); 
// and unref() somehow disentangles the child's event loop from the parent's: 
child.unref(); 
child.stdout.on('data', function(data) {
    console.log(data.toString()); 
});

Сейчас (6 лет спустя) все намного проще!

Spawn возвращает childObject, с помощью которого затем можно прослушивать события. События:

• Class: ChildProcess
  • Event: 'error'
  • Событие: «выход»
  • Событие: «закрыть»
  • Событие: "отключиться"
  • Событие: "сообщение"

Также есть набор объектов из childObject, это:

• Class: ChildProcess
  • child.stdin
  • child.stdout
  • child.stderr
  • child.stdio
  • child.pid
  • child.connected
  • child.kill ([сигнал])
  • child.send (сообщение [, sendHandle] [, обратный вызов])
  • child.disconnect ()

См. Дополнительную информацию о childObject здесь: https://nodejs.org/api/child_process.html

Асинхронный

Если вы хотите запустить процесс в фоновом режиме, пока узел все еще может продолжать выполнение, используйте асинхронный метод. Вы по-прежнему можете выполнять действия после завершения процесса и когда у процесса есть какие-либо выходные данные (например, если вы хотите отправить выходные данные сценария клиенту).

child_process.spawn (...); (узел v0.1.90)

var spawn = require('child_process').spawn;
var child = spawn('node ./commands/server.js');

// You can also use a variable to save the output 
// for when the script closes later
var scriptOutput = "";

child.stdout.setEncoding('utf8');
child.stdout.on('data', function(data) {
    //Here is where the output goes

    console.log('stdout: ' + data);

    data=data.toString();
    scriptOutput+=data;
});

child.stderr.setEncoding('utf8');
child.stderr.on('data', function(data) {
    //Here is where the error output goes

    console.log('stderr: ' + data);

    data=data.toString();
    scriptOutput+=data;
});

child.on('close', function(code) {
    //Here you can get the exit code of the script

    console.log('closing code: ' + code);

    console.log('Full output of script: ',scriptOutput);
});

Вот как использовать обратный вызов + асинхронный метод:

var child_process = require('child_process');

console.log("Node Version: ", process.version);

run_script("ls", ["-l", "/home"], function(output, exit_code) {
    console.log("Process Finished.");
    console.log('closing code: ' + exit_code);
    console.log('Full output of script: ',output);
});

console.log ("Continuing to do node things while the process runs at the same time...");

// This function will output the lines from the script 
// AS is runs, AND will return the full combined output
// as well as exit code when it's done (using the callback).
function run_script(command, args, callback) {
    console.log("Starting Process.");
    var child = child_process.spawn(command, args);

    var scriptOutput = "";

    child.stdout.setEncoding('utf8');
    child.stdout.on('data', function(data) {
        console.log('stdout: ' + data);

        data=data.toString();
        scriptOutput+=data;
    });

    child.stderr.setEncoding('utf8');
    child.stderr.on('data', function(data) {
        console.log('stderr: ' + data);

        data=data.toString();
        scriptOutput+=data;
    });

    child.on('close', function(code) {
        callback(scriptOutput,code);
    });
}

Используя описанный выше метод, вы можете отправить клиенту каждую строку вывода сценария (например, используя Socket.io для отправки каждой строки при получении событий на stdout или stderr).

Синхронный

Если вы хотите, чтобы узел остановил свои действия и дождался завершения скрипта, вы можете использовать синхронную версию:

child_process.spawnSync (...); (узел v0.11.12 +)

Проблемы с этим методом:

• Если сценарий требует времени для завершения, ваш сервер зависнет на это время!
• Стандартный вывод будет возвращен только после завершения выполнения скрипта. Поскольку он синхронный, он не может продолжаться, пока не закончится текущая строка. Следовательно, он не может захватить событие 'stdout', пока не завершится линия появления.

Как это использовать:

var child_process = require('child_process');

var child = child_process.spawnSync("ls", ["-l", "/home"], { encoding : 'utf8' });
console.log("Process finished.");
if(child.error) {
    console.log("ERROR: ",child.error);
}
console.log("stdout: ",child.stdout);
console.log("stderr: ",child.stderr);
console.log("exist code: ",child.status);

Вот самый чистый подход, который я нашел:

require("child_process").spawn('bash', ['./script.sh'], {
  cwd: process.cwd(),
  detached: true,
  stdio: "inherit"
});

У меня были небольшие проблемы с получением вывода журнала из команды "npm install", когда я создал npm в дочернем процессе. В родительской консоли не отображалось ведение журнала зависимостей в реальном времени.

Самый простой способ сделать то, что хочет исходный плакат, выглядит следующим образом (создать npm в Windows и записать все в родительскую консоль):

var args = ['install'];

var options = {
    stdio: 'inherit' //feed all child process logging into parent process
};

var childProcess = spawn('npm.cmd', args, options);
childProcess.on('close', function(code) {
    process.stdout.write('"npm install" finished with code ' + code + '\n');
});

PHP-подобный переход

import { spawn } from 'child_process';

export default async function passthru(exe, args, options) {
    return new Promise((resolve, reject) => {
        const env = Object.create(process.env);
        const child = spawn(exe, args, {
            ...options,
            env: {
                ...env,
                ...options.env,
            },
        });
        child.stdout.setEncoding('utf8');
        child.stderr.setEncoding('utf8');
        child.stdout.on('data', data => console.log(data));
        child.stderr.on('data', data => console.log(data));
        child.on('error', error => reject(error));
        child.on('close', exitCode => {
            console.log('Exit code:', exitCode);
            resolve(exitCode);
        });
    });
}

Использование

const exitCode = await passthru('ls', ['-al'], { cwd: '/var/www/html' })

ребенок:

setInterval(function() {
    process.stdout.write("hi");
}, 1000); // or however else you want to run a timer

родитель:

require('child_process').fork('./childfile.js');
// fork'd children use the parent's stdio

Я обнаружил, что мне нужна эта функция достаточно часто, поэтому я упаковал ее в библиотеку под названием std-pour. Он должен позволить вам выполнить команду и просмотреть результат в реальном времени. Для простой установки:

npm install std-pour

Тогда достаточно просто выполнить команду и увидеть результат в реальном времени:

const { pour } = require('std-pour');
pour('ping', ['8.8.8.8', '-c', '4']).then(code => console.log(`Error Code: ${code}`));

Обещано, что вы можете связать несколько команд в цепочку. Это даже функция, совместимая с сигнатурой child_process.spawn, поэтому она должна быть заменой везде, где вы Используем это.

Добавление образца для exec, так как мне тоже требовалась обратная связь в реальном времени, и я не получал ее, пока не закончил скрипт. exec действительно возвращает EventEmitter, вопреки многим утверждениям, что только spawn работает таким образом.

Это более подробно дополняет мой комментарий к принятому ответу.

Интерфейс для exec похож на spawn:

// INCLUDES
import * as childProcess from 'child_process'; // ES6 Syntax
    
    
// DEFINES
let exec = childProcess.exec; // Use 'var' for more proper 
                              // semantics, or 'const' it all
                              // if that's your thing; though 'let' is 
                              // true-to-scope;

// Return an EventEmitter to work with, though
// you can also chain stdout too: 
// (i.e. exec( ... ).stdout.on( ... ); )
let childProcess = exec
(
    './binary command -- --argument argumentValue',
    ( error, stdout, stderr ) =>
    {    // When the process completes:
        if( error )
        {   
            console.log( `${error.name}: ${error.message}` );
            console.log( `[STACK] ${error.stack}` );
        }
            
        console.log( stdout );
        console.log( stderr );
        callback();                // Gulp stuff
    }
);

Теперь это так же просто, как зарегистрировать обработчик событий для stdout:

childProcess.stdout.on( 'data', data => console.log( data ) );

И для stderr:

childProcess.stderr.on( 'data', data => console.log( `[ERROR]: ${data}` ) );

Вы также можете pipe stdout в stdout основного процесса:

childProcess.stdout.pipe( process.stdout );

Совсем неплохо - HTH