Retry a promise step

问题:

Suppose I have the the following Promise chain:

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

Now I have not only one transformData function but two or more, stored in an array. I want to try the first one, and if the compileData function fails, try the second one and so on until either compileData succeeds or the array of transformData functions is exhausted.

Can someone give me an example on how to implement this?

Running all transformData functions and give the result array to compileData is not an option, since the functions are very expensive and I want to run as few as possible of them.

transformData itself also returns a Promise, if that helps.

回答1:

I would start by isolating the notion of trying a number of promises until one succeeds:

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

Now write a handler which tries each combination of transforming and compiling:

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

Now the top level is just:

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

By the way, Promise.resolve(filename).then(unpackDataFromFile) is just a roundabout way of saying unpackDataFromFile(filename).

回答2:

You can do something like this:

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

Here's how this works:

1. Sets up a tIndex variable that indexes into the array of transformer functions.
2. Calls unpackDataFromFile(filename) and saves the resulting promise.
3. Then executes the sequence p.then(transformer).then(compileData) using the first transformer. If that succeeds, it calls writeData and returns the resulting promise.
4. If either the transformer or compileData fails, then it goes to the next transformer function and starts over. The key here to making this work is that in the .catch() handler, it returns a new promise which chains into the originally returned promise. Each new call to run() is chained onto the original promise from unpackDataFromFile() which allows you to reuse that result.

---

Here's a bit more generic implementation that makes an iterator for an array that iterates until the iterator callback returns a promise that fulfills.

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

回答3:

The following should do what you want most idiomatically:

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

Basically you recurse on the transformers array, using .catch().