javascript - Promise.resolve() 什么时候触发 then() 方法？

Question

这个问题在这里已经有了答案:





What is the difference between returned Promise?

(2 个回答)



ES6 promise execution order for returned values

(2 个回答)



Promise `then` with a function returning nothing vs with a function returning an another promise

(1 个回答)



Why does this async function execute before the equivalent Promise.then chain defined before it?

(2 个回答)


去年关闭。




我正在学习 js 中的 Promise，对此我有一些疑问，这里是代码:

Promise.resolve().then(() => {
  console.log(0);
  return Promise.resolve(4);
}).then((res) => {
  console.log(res)
})

Promise.resolve().then(() => {
  console.log(1);
}).then(() => {
  console.log(2);
}).then(() => {
  console.log(3);
}).then(() => {
  console.log(5);
}).then(() => {
  console.log(6);
})

输出与我的预期相差甚远，我认为它会是 0 1 4 2 3 5 6，因为我在 MDN 上看到了这个

the Promise.resolve() method returns a Promise object that is resolved with a given value

所以不应该在数字 1 后面触发 log() 方法吗？
我究竟做错了什么？

Answer 1

Promise 不是直接处理的，而是基于队列的。如果 promise 完成，则在下一个处理周期中处理回调。
如果我们用更详细的代码替换您的代码，我们会得到:

const a = Promise.resolve('a');

const b = a.then(() => {
  console.log('b');
  const c = Promise.resolve('c');
  return c;
});

const ca = b.then((res) => {
  console.log('ca', res)
})

const u = Promise.resolve('u');

const v = u.then(() => {
  console.log('v');
});

const w = v.then(() => {
  console.log('w');
});

const x = w.then(() => {
  console.log('x');
});

const y = x.then(() => {
  console.log('y');
});

const z = y.then(() => {
  console.log('z');
});

首先通过代码从上到下运行并且没有发生很多事情。两个 Promise 已解决( a 和 u )被放入队列中，并且没有打印任何内容。当它们在下一个周期中被处理时，它们会排队 b和 v .
每当处理下一个循环时， b是第一个，日志 "b"并将 c 排队.之后， v已处理，记录 "v"和队列 w .
现在， c完成，并将下一个 ca 排队(间接，因为在 promise 中返回 promise )，但不打印任何内容。等等。
一路下来，它看起来像这样:

// Main tick
// - queue a
// - queue u

// Queue tick
// - resolve a, queues b
// - (log nothing)
// - resolve u, queues v
// - (log nothing)

// Queue tick
// - resolve b, queues c
// - log "b"
// - resolve v, queues w
// - log "v"

// Queue tick
// - resolve c, doesnt log, queues the next (ca)
// - resolve w, queues x
// - log "w"

// Queue tick
// - resolve x, queues y
// - log "x"
// - resolve ca, queues nothing
// - log "ca, c"

// Queue tick
// - resolve y, queues z
// - log "y"

// Queue tick
// - resolve z
// - log "z"

我不知道这是否是实际要求，因此如果实现(浏览器)决定直接处理 promise ，则顺序可能会改变。我认为这不太可能，因为它不鼓励公平，并且如果一个 promise 被永远链接起来，这个 promise 将获得分配给它的所有资源。
我认为一般建议是不依赖于完成 promise 的顺序。想想 a.then(b)如， b仅在 a 之后发生完成了，不早了，仅此而已。
如果您需要多个 promise 相互依赖，请使用 Promise.all()或 Promise.any() .