当一个承诺 returns 另一个承诺的 resolve 回调时，它是如何工作的？

Question

在工作中，我们一遍又一遍地使用代码结构。我们都同意它确实有效，但我们不知道它为什么有效。这让我很不舒服。

我制作了一个fiddle，显示了代码结构的简化版本。它运行。谁能告诉我这是怎么回事？

谢谢。

我猜 url 没用。我已经更改了它，但这里还有代码：

function promiseAfter(seconds) {
  var promise = new Promise( (resolve) => {
    setTimeout(function () {resolve()}, 1000 * seconds)
  })
  return promise;
}

function dog() {
  console.log('Dog has started')
  cat().then(function () {
    console.log('In Dog. Cat has finished')
  })
  console.log('Dog has finished')
}

function cat() {
  console.log('Cat has started')
  return promiseAfter(1).then( () => {
    console.log('In Cat.  Outer promise satisfied')
    return promiseAfter(1).then( () => {
      console.log('In Cat.  Inner promise satisfied')
    })
  })
  console.log('Anything after the return stmt in Cat is never executed')
}

dog();

Answer 1

您的代码中发生的情况是：

dog() calls cat(), cat call promise promiseAfter(1), promiseAfter(1) returns 一个 Promise 会在 1 秒后 resolved，在这 1 秒过去之后，promise 已经已解决 "cat" 的第二个 promiseAfter(1) 将被调用（最内层的），这个新的 promiseAfter(1) 将在 1 秒后再次被解决，然后 "cat().then" 在 "dog" fn 将被触发，完成调用。

它是如何工作的？

"cat" 函数 return 是第一次调用 "promiseAfter(1)" 时生成的承诺，这个承诺与内部承诺 return 链接在一起 "promiseAfter(1)"。所以cat只会被resolved，在第一个"promiseAfter(1)"被resolved的时候调用"then" of "cat().then"，而第一个"promiseAfter(1)"只有在inner "promiseAfter(1)"之后才会被resolved ] 已解决。

承诺和承诺链：

我看到您对嵌套承诺有疑问，所以我会尝试更详细地解释一下。

只是为了强调这个概念，一个 promise 是一个对象 "that represents an operation that hasn't completed yet, but is expected in the future"（来自 https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Promise），这个对象有一个方法叫做 "then"，然后只有当你的 promise 对象被触发时已解决，所以

var promise = new Promise( (resolve) => {
    setTimeout(function () {resolve()}, 1000 * seconds)
})

// below the anonymous function passed to ".then" will only be called after 1 second (after the timeout is triggered and resolve() is called)
promise.then(function() { ... })

现在，return输入您的代码：

function cat() {
  return promiseAfter(1).then( () => { // will be resolved and call this anonymous function after 1 second
    console.log('In Cat.  Outer promise satisfied')
    return promiseAfter(1).then( () => { // will be resolved and call this anonymous function after the outer promise is resolved (1 second) and after 1 second has passed, so this will be called after 2 seconds
      console.log('In Cat.  Inner promise satisfied')
    })
  })
};

你已经知道 promiseAfter(1) 会给你一个承诺，这个承诺将在 1 秒后被解决。问题是，外部 promiseAfter(1) 调用其 "then" 方法 传递一个匿名函数，该函数 return 是另一个 promiseAfter(1)，这对什么是至关重要的发生在这里，你 return 匿名函数中的一个新的 promise 对象传递给外部 promiseAfter(1) 的 .then 方法 的事实使其采用内部 promiseAfter(1) 的最终状态)。所以最后"cat()"会给你一个promise对象，只有最里面的"promiseAfter(1)"被resolved才会被resolved，而inner只会在outer被resolved（1秒）和1秒后才被resolved更多的第二遍（1 次解析外部，加上 1 次内部的 setTimeout 完成）。enter code here

当一个承诺 returns 另一个承诺的 resolve 回调时，它是如何工作的？

When the resolve callback from one promise returns another promise, how does it work?

javascript

es6-promise