NodeJS - 在数组中的每个元素之间按顺序循环遍历数组

Question

我有一个数组中的命令列表，我需要按顺序运行：

const commands = [
  `git clone https://github.com/EliLillyCo/${repo}.git`,
  `cd ${repo}`, `git checkout -b ${branch}`,
  'cp ../codeql-analysis.yml .github/workflows/',
  'git add .github/workflows/codeql-analysis.yml',
  `git push --set-upstream origin ${branch}`,
  'cd ../',
  `rm -r  ${repo}`,
];

它们需要按顺序运行，因为命令依赖于正在运行的前一个命令。

另外，每个命令在运行下一个命令之前需要等待 3 秒，因为有时命令需要时间，尤其是命令 1 和命令 5。

我正在使用标准的 for 循环，然后使用 setTimeout() 调用函数来运行命令，如下所示：

const a = require('debug')('worker:sucess');
const b = require('debug')('worker:error');

const { exec } = require('child_process');

function execCommand(command) {
  exec(command, (error, stdout, stderr) => {
    if (error) {
      b(`exec error: ${error}`);
      return;
    }
    a(`stdout: ${stdout}`);
    b(`stderr: ${stderr}`);
  });
}

const commands = [
   `git clone https://github.com/EliLillyCo/${repo}.git`,
   `cd ${repo}`, `git checkout -b ${branch}`,
   'cp ../codeql-analysis.yml .github/workflows/',
   'git add .github/workflows/codeql-analysis.yml',
   `git push --set-upstream origin ${branch}`,
   'cd ../',
   `rm -r  ${repo}`,
 ];

for (let i = 0; i < commands.length; i++) {
  setTimeout(execCommand(commands[i]), 3000);
}

但是setTimeout() 有问题，因为它返回了这个：

  worker:error TypeError [ERR_INVALID_CALLBACK]: Callback must be a function. Received undefined

在使用超时的同时，解决顺序循环数组问题的最佳方法是什么？

Answer 1

我会让execCommand 返回一个承诺，这样你就知道什么时候完成了；您不能依赖超时（如果任务花费超过 3 秒怎么办？），并且由于大多数命令的完成速度会比这快很多，超时会不必要地拖延。

这里是 execCommand 返回一个承诺：

function execCommand(command) {
    return new Promise((resolve, reject) => {
        exec(command, (error, stdout, stderr) => {
            if (error) {
                b(`exec error: ${error}`);
                reject(error);
                return;
            }
            a(`stdout: ${stdout}`);
            b(`stderr: ${stderr}`);
            resolve();
        });
    });
}

那么，如果您有可用的顶级 await（现代 Node.js 和 ESM 模块）：

// If you have top-level `await` available
try {
    for (const commmand of commands) {
        await execCommand(command);
    }
} catch (error) {
    // ...report/handle error...
}

如果不这样做，请将其包装在 async IIFE 中：

(async () => {
    for (const commmand of commands) {
        await execCommand(command);
    }
})().catch(error => {
    // ...report/handle error...
});

---

或者，如果您想将执行与stdout/stderr 的处理分开，您可以直接在exec 上使用util.promisify，但是将它们一起执行对您所拥有的内容的最小更改，所以这就是我坚持的。

Answer 2

目前，您不能保证在调用下一个命令时会完成上一个命令。您会在 3000 毫秒后自动调用下一个，但上一个可能需要比预期更长的时间并且尚未结束。

您应该添加一种机制来等待每个命令，然后启动下一个命令。以下是使用async/await 的方法：

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

const commands = [ ... ];

const execCommand = async (command) => {
    try {
        await exec(command)
    } catch (error) {
        b(`exec error: ${error}`);
        return;
    }
    a(`stdout: ${stdout}`);
    b(`stderr: ${stderr}`);
}

(async () => {
    for (let command of commands) {
        await execCommand(command);
    }
})();