如何使用 Bluebird 承诺 Node 的 child_process.exec 和 child_process.execFile 函数？

Question

我正在使用 Node.js 下的 Bluebird promise 库，非常棒！但我有一个问题：

如果您查看 Node 的 child_process.exec and child_process.execFile 文档，您会发现这两个函数都是 return 一个 ChildProcess 对象。

那么推荐的 promise 此类功能的方法是什么？

请注意以下工作（我得到一个 Promise 对象）：

var Promise = require('bluebird');
var execAsync = Promise.promisify(require('child_process').exec);
var execFileAsync = Promise.promisify(require('child_process').execFile);

但是如何才能访问原始 Node.js 函数的原始 return 值呢？（在这些情况下，我需要能够访问最初的 returned ChildProcess 对象。）

如有任何建议，我们将不胜感激！

编辑：

这是一个使用 child_process.exec 函数的 return 值的示例代码：

var exec = require('child_process').exec;
var child = exec('node ./commands/server.js');
child.stdout.on('data', function(data) {
    console.log('stdout: ' + data);
});
child.stderr.on('data', function(data) {
    console.log('stderr: ' + data);
});
child.on('close', function(code) {
    console.log('closing code: ' + code);
});

但是如果我使用 exec 函数的 promisified 版本（上面的 execAsync ），那么 return 值将是一个 promise，而不是 ChildProcess 对象。这才是我说的真正的问题。

Answer 1

听起来您想 return 通话中的两件事：

子进程
当 ChildProcess 完成时解析的承诺

那么“承诺此类功能的推荐方式”？不要.

您不在会议范围内。 Promise returning 函数需要 return 一个 promise，仅此而已。您可以 return 具有两个成员（ChildProcess 和 promise）的 object，但这只会让人感到困惑。

我建议调用 unpromisified 函数，并基于 returned childProcess 创建一个 promise。（也许将其包装到辅助函数中）

这样，对于下一个阅读代码的人来说就很明确了。

类似于：

var Promise = require('bluebird');
var exec = require('child_process').execFile;

function promiseFromChildProcess(child) {
    return new Promise(function (resolve, reject) {
        child.addListener("error", reject);
        child.addListener("exit", resolve);
    });
}

var child = exec('ls');

promiseFromChildProcess(child).then(function (result) {
    console.log('promise complete: ' + result);
}, function (err) {
    console.log('promise rejected: ' + err);
});

child.stdout.on('data', function (data) {
    console.log('stdout: ' + data);
});
child.stderr.on('data', function (data) {
    console.log('stderr: ' + data);
});
child.on('close', function (code) {
    console.log('closing code: ' + code);
});

如果您只想具体地承诺 child_process.exec() 和 child_process.execFile()，在最近的节点版本中有更好的答案 here。

Answer 2

可能没有一种方法可以很好地涵盖所有用例。但在有限的情况下，您可以这样做：

/**
 * Promisified child_process.exec
 *
 * @param cmd
 * @param opts See child_process.exec node docs
 * @param {stream.Writable} opts.stdout If defined, child process stdout will be piped to it.
 * @param {stream.Writable} opts.stderr If defined, child process stderr will be piped to it.
 *
 * @returns {Promise<{ stdout: string, stderr: stderr }>}
 */
function execp(cmd, opts) {
    opts || (opts = {});
    return new Promise((resolve, reject) => {
        const child = exec(cmd, opts,
            (err, stdout, stderr) => err ? reject(err) : resolve({
                stdout: stdout,
                stderr: stderr
            }));

        if (opts.stdout) {
            child.stdout.pipe(opts.stdout);
        }
        if (opts.stderr) {
            child.stderr.pipe(opts.stderr);
        }
    });
}

它接受 opts.stdout 和 opts.stderr 参数，因此可以从子进程中捕获 stdio。

例如：

execp('ls ./', {
    stdout: new stream.Writable({
        write: (chunk, enc, next) => {
            console.log(chunk.toString(enc));
            next();
        }
    }),
    stderr: new stream.Writable({
        write: (chunk, enc, next) => {
            console.error(chunk.toString(enc));
            next();
        }
    })
}).then(() => console.log('done!'));

或者简单地说：

execp('ls ./', {
    stdout: process.stdout,
    stderr: process.stderr
}).then(() => console.log('done!'));

Answer 3

只是想提一下，有一个很好的工具可以完全解决您的问题：

https://www.npmjs.com/package/core-worker

这个包使得处理流程变得更加容易。

import { process } from "CoreWorker";
import fs from "fs";

const result = await process("node Server.js", "Server is ready.").ready(1000);
const result = await process("cp path/to/file /newLocation/newFile").death();

或结合这些功能：

import { process } from "core-worker";

const simpleChat = process("node chat.js", "Chat ready");

setTimeout(() => simpleChat.kill(), 360000); // wait an hour and close the chat

simpleChat.ready(500)
    .then(console.log.bind(console, "You are now able to send messages."))
    .then(::simpleChat.death)
    .then(console.log.bind(console, "Chat closed"))
    .catch(() => /* handle err */);

Answer 4

这是另一种方式：

function execPromise(command) {
    return new Promise(function(resolve, reject) {
        exec(command, (error, stdout, stderr) => {
            if (error) {
                reject(error);
                return;
            }

            resolve(stdout.trim());
        });
    });
}

使用函数：

execPromise(command).then(function(result) {
    console.log(result);
}).catch(function(e) {
    console.error(e.message);
});

或 async/await:

try {
    var result = await execPromise(command);
} catch (e) {
    console.error(e.message);
}

Answer 5

我建议使用语言内置的标准 JS 承诺，而不是像 Bluebird 这样的附加库依赖项。

如果您使用的是 Node 10+，the Node.js docs 建议使用 util.promisify，其中 returns 一个 Promise<{ stdout, stderr }> 对象。请参阅下面的示例：

const util = require('util');
const exec = util.promisify(require('child_process').exec);

async function lsExample() {
  try {
    const { stdout, stderr } = await exec('ls');
    console.log('stdout:', stdout);
    console.log('stderr:', stderr);
  } catch (e) {
    console.error(e); // should contain code (exit code) and signal (that caused the termination).
  }
}
lsExample()

首先处理来自 stderr 的错误。

Answer 6

这是我的。它不处理 stdin 或 stdout，因此如果您需要这些，请使用此页面上的其他答案之一。 :)

// promisify `child_process`
// This is a very nice trick :-)
this.promiseFromChildProcess = function (child) {
    return new Promise((resolve, reject) => {
        child.addListener('error', (code, signal) => {
            console.log('ChildProcess error', code, signal);
            reject(code);
        });
        child.addListener('exit', (code, signal) => {
            if (code === 0) {
                resolve(code);
            } else {
                console.log('ChildProcess error', code, signal);
                reject(code);
            }
        });
    });
};

Answer 7

自 Node v12 起，内置 util.promisify 允许访问返回的 Promise 中的 ChildProcess 对象，用于内置函数，它本应由 un-承诺的电话。来自 docs:

The returned ChildProcess instance is attached to the Promise as a child property.

这正确而简单地满足了在原始问题中访问 ChildProcess 的需要，并使 其他答案过时，前提是可以使用 Node v12+。

改编提问者提供的示例（和简洁风格），可以像这样实现对ChildProcess的访问：

const util = require('util');
const exec = util.promisify(require('child_process').exec);
const promise = exec('node ./commands/server.js');
const child = promise.child; 

child.stdout.on('data', function(data) {
    console.log('stdout: ' + data);
});
child.stderr.on('data', function(data) {
    console.log('stderr: ' + data);
});
child.on('close', function(code) {
    console.log('closing code: ' + code);
});

// i.e. can then await for promisified exec call to complete
const { stdout, stderr } = await promise;

Answer 8

这是我的两分钱。使用 spawn 流式传输输出并写入 stdout 和 stderr。错误和标准输出在缓冲区中捕获并返回或拒绝。

这是我用 Typescript 写的，如果使用 JavaScript，请随意删除打字：

import { spawn, SpawnOptionsWithoutStdio } from 'child_process'

const spawnAsync = async (
  command: string,
  options?: SpawnOptionsWithoutStdio
) =>
  new Promise<Buffer>((resolve, reject) => {
    const [spawnCommand, ...args] = command.split(/\s+/);
    const spawnProcess = spawn(spawnCommand, args, options);
    const chunks: Buffer[] = [];
    const errorChunks: Buffer[] = [];
    spawnProcess.stdout.on("data", (data) => {
      process.stdout.write(data.toString());
      chunks.push(data);
    });
    spawnProcess.stderr.on("data", (data) => {
      process.stderr.write(data.toString());
      errorChunks.push(data);
    });
    spawnProcess.on("error", (error) => {
      reject(error);
    });
    spawnProcess.on("close", (code) => {
      if (code === 1) {
        reject(Buffer.concat(errorChunks).toString());
        return;
      }
      resolve(Buffer.concat(chunks));
    });
  });

Answer 9

再举一个例子，当运行使用相同的常量解构多个命令时，您可能运行遇到问题，您可以像这样重命名它们。

const util = require('util');
const exec = util.promisify(require('child_process').exec);

async function runCommands() {
    try {
        const { stdout, stderr } = await exec('ls');
        console.log('stdout:', stdout);
        console.log('stderr:', stderr);

        const { stdout: stdoutTwo, stderr: stderrTwo } = await exec('ls');
        console.log('stdoutTwo:', stdoutTwo);
        console.log('stderrTwo:', stderrTwo);

        const { stdout: stdoutThree, stderr: stderrThree } = await exec('ls');
        console.log('stdoutThree:', stdoutThree);
        console.log('stderrThree:', stderrThree);

    } catch (e) {
        console.error(e); // should contain code (exit code) and signal (that caused the termination).
    }
}
runCommands()

如何使用 Bluebird 承诺 Node 的 child_process.exec 和 child_process.execFile 函数？

How to promisify Node's child_process.exec and child_process.execFile functions with Bluebird?

javascript

node.js

promise

bluebird