如何在拒绝时链接承诺

Question

给定一个函数fn，它返回一个promise，以及一个任意长度的数据数组（例如data = ['apple', 'orange', 'banana', ...]），你如何按顺序对数组的每个元素进行函数调用，这样如果fn(data[i])解决，整个链完成并停止调用fn，但如果fn(data[i]) 拒绝，下一个调用fn(data[i + 1]) 执行？

这是一个代码示例：

// this could be any function which takes input and returns a promise
// one example might be fetch()
const fn = datum =>
  new Promise((resolve, reject) => {
    console.log(`trying ${datum}`);

    if (Math.random() < 0.25) {
      resolve(datum);
    } else {
      reject();
    }
  });

const foundResult = result => {
  // result here should be the first value that resolved from fn(), and it
  // should only be called until the first resolve()
  console.log(`result = ${result}`);
};

// this data can be purely arbitrary length
const data = ['apple', 'orange', 'banana', 'pineapple', 'pear', 'plum'];

// this is the behavior I'd like to model, only for dynamic data
fn('apple').then(foundResult)
  .catch(() => {
    fn('orange').then(foundResult)
      .catch(() => {
        fn('banana').then(foundResult)
          .catch(() => {
            /* ... and so on, and so on ... */
          });
      });
  });

我觉得我缺少的这种模式可能有一个优雅的解决方案。该行为与Array.some() 非常相似，但我试图摆弄它是空的。

编辑：我从数字数据切换到字符串，以强调解决方案不需要依赖于数字数据。

编辑#2：为了进一步澄清，fn 可以是任何接受输入并返回承诺的函数。上面的fn 实现只是为了给出一个完整的例子。实际上，fn 实际上可能是 API 请求、数据库查询等。

Answer 1

编写如下搜索函数：

function search(number) {
    if (number < data.length) {
        fn(data[number]).then(foundResult)
              .catch(() => search(number + 1));
    }
}

search(0);

Answer 2

我猜你正在尝试做的事情可以这样做（它不是严格等价的，请参阅下面的储备）：

const fn = n => new Promise(() => {});
const seq = [];
const process = n => fn(n).then(foundResult);

seq.slice(1).reduce((operation, item) => {

    return operation
        .catch(() => process(item));

}, process(seq[0]));

与Promise.race：

const fetchAll = ( urls = [] ) => Promise.race(urls.map(fn)).then(foundResult);

但是我不确定这是您想要实现的目标：例如，在您的 sn-p 中，您没有在 catch 处理程序中返回任何内容，这意味着 foundResult 很可能是副作用。此外，在阅读您的代码 sn-p 时，您会发现可以从 foundResult 内部引发的错误，而不是从 fn 函数引发的错误。

根据经验，我总是尝试让我的承诺通过已知的“类型”来实现，或者因为错误而被拒绝。在您的示例中不清楚您正在生成的承诺将以任何值结算，无论是 rejectionValue 还是 fulfillmentValue。

也许如果你能提供一个用例，我可以帮你一点。

Answer 3

你可以使用async/await 和一个循环：

async function search() {
  for (let item of data) {
    try {
      return await fn(item);
    } catch (err) { }
  }
  throw Error ("not found"); 
}

search().then(foundResult).catch(console.log);

• fn 可以返回 Promise（等待）或简单的值（返回）
• 您的data 可能是一个无限的iterable 序列（生成器）
• 在我看来，它也易于阅读和理解意图。

这是序列失败时的输出：

trying apple
trying orange
trying banana
trying pineapple
trying pear
trying plum
Error: not found

es2017 原生支持异步，但可以使用 babel 或 typescript 转译为 es3/es5

Answer 4

您可以使用 Array.reduce 来获取所需的数据。

data.reduce((promise, item) => promise.then(
  (param) => {
    if (param) return Promise.resolve(param);
    return fn(item).catch(() => Promise.resolve());
  } 
), Promise.resolve())
.then(foundResult)

基本上，一旦通过，它就会将结果传递到最后。如果fn 失败，它会将未定义值的promise 传递给下一个链来触发fn。

Answer 5

您可以编写一个非常简单的递归函数，该函数将在第一次解析时停止并在捕获时递归。

function find_it(arr) {
   let [head, ...rest] = arr

   if (!head) return console.log("not found") // all rejects or no data

   fn(head)
   .then(r => foundResult(r) )
   .catch(r => find_it(rest))
}
find_it(data)

这样做的好处是在第一次匹配时停止而不调用所有值（如果找到匹配项）并且不关心 data 的长度，除非您超出递归中的堆栈大小。当然，当所有承诺都拒绝做某事时，在边缘情况下修改操作很容易。

找到结果：

$ 节点 ./test
尝试苹果
尝试橙色
结果=橙色

没有找到：

$ 节点 ./test 尝试苹果
尝试橙色
尝试香蕉
尝试菠萝
尝试梨
尝试李子
没找到