重试承诺步骤

Question

假设我有以下 Promise 链：

var result = Promise.resolve(filename)
    .then(unpackDataFromFile)
    .then(transformData)
    .then(compileDara)
    .then(writeData);

现在我不仅有一个transformData 函数，而且还有两个或更多，存储在一个数组中。我想尝试第一个，如果 compileData 函数失败，请尝试第二个，依此类推，直到 compileData 成功或 transformData 函数数组耗尽。

谁能给我一个如何实现的例子？

运行所有transformData 函数并将结果数组提供给compileData 不是一种选择，因为这些函数非常昂贵，我希望尽可能少地运行它们。

transformData 本身也返回一个 Promise，如果有帮助的话。

Answer 1

你可以这样做：

// various transformer functions to try in order to be tried
var transformers = [f1, f2, f3, f4];    

function transformFile(filename) {
    // initialize tIndex to select next transformer function
    var tIndex = 0;
    var p = unpackDataFromFile(filename);

    function run() {
          return p.then(transformers[tIndex++])
          .then(compileData)
          .catch(function(err) {
              if (tIndex < transformers.length) {
                // execute the next transformer, returning
                // a promise so it is linked into the chain
                return run();
              } else {
                // out of transformers, so reject and stop
                throw new Error("No transformer succeeded");
              }
          }).then(writeData);

    }
    return run();
}

transformFile("someData.txt").then(function(finalResult) {
    // succeeded here
}).catch(function(err) {
    // error here
});

这是如何工作的：

1. 设置一个tIndex 变量，该变量索引到转换器函数数组。
2. 调用unpackDataFromFile(filename) 并保存生成的承诺。
3. 然后使用第一个转换器执行序列p.then(transformer).then(compileData)。如果成功，它会调用 writeData 并返回结果。
4. 如果转换器或 compileData 失败，则它会转到下一个转换器函数并重新开始。完成这项工作的关键在于，在 .catch() 处理程序中，它返回一个新的 Promise，该 Promise 链接到最初返回的 Promise 中。对 run() 的每个新调用都链接到来自 unpackDataFromFile() 的原始承诺，这样您就可以重用该结果。

---

这里有一个更通用的实现，它为数组创建迭代器，直到迭代器回调返回一个满足的承诺。

// Iterate an array using an iterator that returns a promise
// Stop iterating as soon as you get a fulfilled promise from the iterator
// Pass:
//    p - Initial promise (can be just Promise.resolve(data))
//    array - array of items to pass to the iterator one at a time
//    fn - iterator function that returns a promise
//         iterator called as fn(data, item)
//             data - fulfilled value of promise passed in
//             item - array item for this iteration
function iterateAsyncUntilSuccess(p, array, fn) {
    var index = 0;

    function next() {
        if (index < array.length) {
            var item = array[index++];
            return p.then(function(data) {
                return fn(data, item).catch(function(err) {
                    // if this one fails, try the next one
                    return next();
                });
            });
        } else {
            return Promise.reject(new Error("End of data with no operation successful"));
        }
    }

    return next();
}

// Usage:
// various transformer functions to try in order to be tried
var transformers = [f1, f2, f3, f4];    

iterateAsyncUntil(unpackDataFromFile(filename), transformers, function(data, item) {
    return item(data).then(compileData);
}).then(writeData).then(function(result) {
    // successfully completed here
}).catch(function(err) {
    // error here
});

Answer 2

我将首先隔离尝试多个承诺直到成功的概念：

function tryMultiple([promise, ...rest]) {
  if (!promise) throw new Error("no more to try");
  return promise.catch(() => tryMultiple(rest));
}

现在编写一个处理程序，尝试转换和编译的每种组合：

function transformAndCompile(transformers) {
  return function(data) {
    return tryMultiple(transformers.map(t => t(data).then(compileData)));
  };
}

现在顶层只是：

var result = Promise.resolve(filename)
  .then(unpackDataFromFile)
  .then(transformAndCompile(transformers))
  .then(writeData);

顺便说一句，Promise.resolve(filename).then(unpackDataFromFile) 只是说unpackDataFromFile(filename) 的一种迂回方式。

Answer 3

以下应该做你最惯用的：

var transformers = [transformData, transformData2];

var result = unpackDataFromFile(filename)
  .then(function transpile(data, i = 0) {
    return transformers[i](data).then(compileData)
      .catch(e => ++i < transformers.length? transpile(data, i) : Promise.reject(e));
  })
  .then(writeData);

基本上，您使用.catch() 对变压器数组进行递归。