执行:显示标准输出“实时”

不要使用 exec .使用spawn，这是一个EventEmmiter对象。然后，您可以收听stdout/stderr事件（spawn.stdout.on('data',callback..)）发生时。

来自 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缓冲输出，通常在命令完成执行后返回输出。

exec还将返回一个作为 EventEmitter 的 ChildProcess 对象。

var exec = require('child_process').exec;
var coffeeProcess = exec('coffee -cw my_file.coffee');
coffeeProcess.stdout.on('data', function(data) {
    console.log(data); 
});

或者pipe子进程的标准输出到主标准输出。

coffeeProcess.stdout.pipe(process.stdout);

或者使用生成继承 stdio

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

已经有几个答案，但是没有一个提到执行此操作的最佳（也是最简单的）方法，即使用spawn和{ stdio: 'inherit' }选项。它似乎会产生最准确的输出，例如在显示来自git clone的进度信息时。

只需这样做：

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

感谢@MorganTouvereyQuilling在此评论中指出这一点。

受到Nathanael Smith的回答和Eric Freese的评论的启发，它可以像这样简单：

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

我只想补充一点，使用 console.log() 从生成的进程中输出缓冲区字符串的一个小问题是它添加了换行符，这可以将生成的进程输出分散到其他行上。如果使用process.stdout.write()而不是console.log()输出stdout或stderr，则"按原样"从生成的进程中获得控制台输出。

我在这里看到了该解决方案：节点.js：打印到控制台而不带尾随换行符？

希望可以帮助使用上述解决方案的人（这对于实时输出来说是一个很好的解决方案，即使它来自文档）。

我发现将自定义 exec 脚本添加到执行此操作的实用程序中很有帮助。

公用事业.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())
  })
}

应用.js

const { exec } = require('./utilities.js')
    
exec('coffee -cw my_file.coffee')

在查看了所有其他答案后，我最终得出了这个答案：

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

有时data将是多行，因此oldSchoolMakeBuild标题将针对多行显示一次。 但这并没有困扰我来改变它。

child_process.spawn 返回一个包含 stdout 和 stderr 流的对象。您可以点击标准输出流来读取子进程发送回 Node 的数据。作为流的 stdout 具有流具有流具有的"数据"、"结束"和其他事件。当您希望子进程将大量数据返回给 Node 时，生成最适合使用——图像处理、读取二进制数据等。

因此，您可以使用下面使用的 child_process.spawn 来解决您的问题。

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

这是一个用打字稿编写的异步帮助程序函数，似乎可以为我解决问题。我想这不适用于长期进程，但对某人来说仍然很方便？

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

我找到了另一种方法：

const { spawn } = require('child_process');
export const execCommand = async (command) => {
  return new Promise((resolve, reject) => {
    const [cmd, ...args] = command.split(' ');
    const childProcess = spawn(cmd, args);
    childProcess.stdout.on('data', (data) => {
      process.stdout.write(data.toString());
    });
    childProcess.stderr.on('data', (data) => {
      process.stderr.write(data.toString());
    });
    childProcess.on('error', (error) => {
      reject(error);
    });
    childProcess.on('exit', (code) => {
      if (code === 0) {
        resolve();
      } else {
        reject(new Error(`Command exited with code ${code}.`));
      }
    });
  });
};

此代码提供了从执行的命令获取实时输出并将所有标准输出和标准derr重定向到父进程的能力。它还允许以与在 bash/sh（单字符串输入）中相同的方式使用该命令。在这里，我使用 process.stdout.write 来获得更准确的输出，而不是在其他答案中使用的console.log。

用法：

await execCommand('sudo apt-get update');
await execCommand('sudo apt-get install -y docker.io docker-compose');

注意：与exec相比，它不支持使用 && 执行多个命令。因此，每个命令都应使用单个execCommand语句执行。

下面是一个同时支持实时流式传输和 shell 执行的简化版本：

const { spawn } = require('child_process');
export const execCommand = async (command) => {
  return new Promise((resolve, reject) => {
    const childProcess = spawn(command, { 
      stdio: 'inherit',
      shell: true
    });
    childProcess.on('error', (error) => {
      reject(error);
    });
    childProcess.on('exit', (code) => {
      if (code === 0) {
        resolve();
      } else {
        reject(new Error(`Command exited with code ${code}.`));
      }
    });
  });
};

用法：

await execCommand('sudo apt-get update && sudo apt-get install -y docker.io docker-compose');