承诺回调返回承诺

Question

关于这两个重要来源：NZakas-
承诺链中的归还承诺
和MDN承诺，我想提出以下问题：

每次我们从承诺履行处理程序返回值时，该值如何传递给从同一处理程序返回的新承诺？

例如，

let p1 = new Promise(function(resolve, reject) {
    resolve(42);
});

let p2 = new Promise(function(resolve, reject) {
    resolve(43);
});

let p3 = p1.then(function(value) {
    // first fulfillment handler
    console.log(value);     // 42
    return p2;
});

p3.then(function(value) {
    // second fulfillment handler
    console.log(value);     // 43
});

在这个例子中，p2是一个承诺。p3也是来自p1履行处理程序的承诺。但是p2 !== p3。取而代之的p2是神奇地解决43（如何？），然后将该值传递给p3的实现处理程序。即使是这里的句子也令人困惑。

您能给我解释一下这到底是怎么回事吗？我对这个概念感到困惑。

Answer 1

假设在then()回调then()函数内部抛出结果会导致失败，并从失败中返回，而从回调函数中返回则实现了成功值。

let p2 = p1.then(() => {
  throw new Error('lol')
})
// p2 was rejected with Error('lol')

let p3 = p1.then(() => {
  return 42
})
// p3 was fulfilled with 42

但是有时候，即使在延续中，我们也不知道我们是否成功。我们需要更多时间。

return checkCache().then(cachedValue => {
  if (cachedValue) {
    return cachedValue
  }

  // I want to do some async work here
})

但是，如果我在那里进行异步工作，那么对return或来说为时已晚throw，不是吗？

return checkCache().then(cachedValue => {
  if (cachedValue) {
    return cachedValue
  }

  fetchData().then(fetchedValue => {
    // Doesn’t make sense: it’s too late to return from outer function by now.
    // What do we do?

    // return fetchedValue
  })
})

这就是为什么如果您 无法解决另一个Promise的原因，Promise 不会有用。

这并不意味着在您的示例p2中将 成为 p3。它们是单独的Promise对象。然而，通过返回p2从then()产生p3你说
“我想要p3解析到任何p2议决，无论成功或失败”。

至于这种情况 如何
发生，则取决于具体实现。在内部，您可以将其then()视为创建新的Promise。该实现将能够在需要时实现或拒绝它。通常，当您返回时，它将自动实现或拒绝它：

// Warning: this is just an illustration
// and not a real implementation code.
// For example, it completely ignores
// the second then() argument for clarity,
// and completely ignores the Promises/A+
// requirement that continuations are
// run asynchronously.

then(callback) {
  // Save these so we can manipulate
  // the returned Promise when we are ready
  let resolve, reject

  // Imagine this._onFulfilled is an internal
  // queue of code to run after current Promise resolves.
  this._onFulfilled.push(() => {
    let result, error, succeeded
    try {
      // Call your callback!
      result = callback(this._result)
      succeeded = true
    } catch (err) {
      error = err
      succeeded = false
    }

    if (succeeded) {
      // If your callback returned a value,
      // fulfill the returned Promise to it
      resolve(result)
    } else {
      // If your callback threw an error,
      // reject the returned Promise with it
      reject(error)
    }
  })

  // then() returns a Promise
  return new Promise((_resolve, _reject) => {
    resolve = _resolve
    reject = _reject
  })
}

同样，这是非常伪的代码，但显示了如何then()在Promise实现中实现的背后思想。

如果我们想增加对解决Promise的支持，我们只需要修改代码以callback在then()返回Promise时传递一个特殊的分支：

    if (succeeded) {
      // If your callback returned a value,
      // resolve the returned Promise to it...
      if (typeof result.then === 'function') {
        // ...unless it is a Promise itself,
        // in which case we just pass our internal
        // resolve and reject to then() of that Promise
        result.then(resolve, reject)
      } else {
        resolve(result)
      }
    } else {
      // If your callback threw an error,
      // reject the returned Promise with it
      reject(error)
    }
  })

让我再次澄清，这不是一个实际的Promise实现，并且有很多漏洞和不兼容之处。但是，它应该使您直观地了解Promise库如何实现解析为Promise。在您对这个想法感到满意之后，我建议您看看实际的Promise实现如何处理此问题。