无法捕获 Promise 队列错误

Question

我正在设置一个节点应用程序，我必须按顺序运行一系列异步生成任务，因此我设置了一个队列系统。当它没有出现错误时，它运行良好。但是，它无法捕获错误并在它们发生时记录它们。这是我现在的位置：

function queue(tasks) {
    let index = 0;
    const runTask = (arg) => {
        if (index >= tasks.length) {
            return Promise.resolve(arg);
        }
        return new Promise((resolve, reject) => {
            tasks[index++](arg).then(arg => resolve(runTask(arg))).catch(reject);
        });
    }
    return runTask();
}

function customSpawn(command, args) {
    return () => new Promise((resolve, reject) => {
        const child = spawn(command, args, {windowsVerbatimArguments: true});
        child.on('close', code => {
            if (code === 0) {
                resolve();
            } else {
                reject();
            }
        });
    });
}

队列是这样构建和执行的：

myqueue.push(customSpawn('cmd.exe', ['/c', convertpath, filelist[i], '-interlace', 'line', '-chop', croppixels, '-resize', '300', outfile]));
queue(myqueue).then(([cmd, args]) => {
        console.log(cmd + ' finished - all finished');
    }).catch(function(error) {
            console.error(error.stack);
            });

抛出以下错误： Uncaught (in promise) TypeError: undefined is not a function(…)

Answer 1

抱歉，我不太了解您的 queue 函数，所以我使用 Array.prototype.reduce 对其进行了重构。这是以紧凑方式链接事物的标准方式。以下模块模拟您的案例并将在节点中运行。它演示了错误处理是如何工作的。如果出现错误，我假设您想中止整个链？

'use strict';
const insp = require('util').inspect;

const size = 10;
const throwAt = 6;

var template = [1,2,3,4,5,6,7,8,9,];
var cmds = template.map((_, i) => ({cmd: `cmd ${_}`, args: [`arg1-${i}`, `arg2-${i}`]}));
var queue = [];

// promise factory
function makePromise (command, args) {
  return () => new Promise((resolve, reject) => {
    setTimeout(_ => {if(command.indexOf(throwAt) > 0) {
      return reject(command);  // whatever is passed here will hit the catch
    }
    console.log(`${command}\t${insp(args)}`);
    resolve()
    }, Math.random() * 1000)
  })
}

// populate the queue
cmds.forEach(c => queue.push(makePromise(c.cmd, c.args)));
// then execute it and catch all errors
queue.reduce((q, p) => q.then(p), Promise.resolve())
  .catch(e => console.log(`error: ${e}`));

你也可以像这样添加一些重试逻辑...

// promise factory
function makePromise (command, args) {
  return () => new Promise((resolve, reject) => {
    setTimeout(_ => {
      if(command.indexOf(throwAt) > 0 && command.indexOf('retry') === -1) {
        return makePromise(command + 'retry', args)()
          .then(_ => resolve(), e => reject(e));
      }
      console.log(`${command}\t${insp(args)}`);
      resolve()
    }, Math.random() * 1000)
  })
}

错误传播

玩这个，我注意到在resolve 或reject 回调中抛出的任何错误都会导致调用块的reject 被调用，并将错误对象作为单个参数传递。这意味着可以抛出错误，而不仅仅是调用reject。这也有提供堆栈跟踪的好处。

管理级联

通过向链中的每个 Promise 添加 reject 回调，可以在需要时管理错误传播。但是，如果添加了 reject 回调，则如果需要传播，则必须重新抛出错误。

这是这两个原则的一个实现...

function makePromise2 (command, args) {
  return (retry) => new Promise((resolve, reject) => {
    if(retry){
      console.log(`throw at ${command}`);
      throw new Error(`sorry, tried twice!`);
    }
    setTimeout(_ => {
      if(command.indexOf(throwAt) > 0) {
/*
        if(retry)   // throwing here will not be handled
          throw new Error(`sorry, tried my best!`);
*/
        return makePromise2(command, args)(true)
          .then(resolve, reject);  // without this it will fail silently
      }
      console.log(`${command}\t${insp(args)}`);
      resolve();
    }, Math.random() * 1000)
  })
}

function Reject (cmd) {
  return function reject (e) {
  console.log(`re-throw at ${cmd.cmd}`);
  throw e;  // if you have a reject callback then you must propagate the error
}}

// populate the queue
cmds.forEach(c => queue.push(makePromise2(c.cmd, c.args)));
// then execute it and catch all errors
// the Reject gives the opportunity to manage the error cascade
queue.reduce((q, p, i) => q.then(p, Reject(cmds[i])), Promise.resolve())
  .catch(e => console.log(`catch...\n${e.stack}`));