JavaScript为什么在外部settimeout之后运行诺言的内部定居点

Question

运行以下代码段时，它会输出2,1。由于Promise是一项微型任务，并且承诺内的所有内容都应在宏观任务（SetteMeout）之前运行，因此我希望输出为1,2。因此，即使微型任务中有宏观任务，我也认为输出将为1,2。

但是它输出2,1。

这里有什么收获？为什么它输出2,1而不是1,2？

Promise.resolve().then(() => {
    setTimeout(() =>{
    console.log("1")
 }, 0)
})

setTimeout(() => {
    console.log("2")
}, 0)

Answer 1

承诺是一项微型任务，将在timeout1之前被执行，但是timeout1已经安排为宏任务。

当承诺解答后，timeout2将被安排，但是Macrotask Q已经具有timeout1，因此已经安排了，并将首先执行。

Answer 2

这是Eventloop（我见过的最佳解释）： https：// https：// https：//ccol7mc4mc4mc4mc4pl0?t？ = 487

console.log("1")
Promise.resolve().then(() => {
    console.log("4")
    setTimeout(() =>{
        console.log("7")
 }, 0)
    console.log("5")
})
console.log("2")
setTimeout(() => {
    console.log("6")
}, 0)
console.log("3")

剪切可能会帮助您了解它的

promis.resolve（）。然后（）与settimout（0）相同
因此，您基本上在timout中写了一个超时，因此Eventloop必须循环两次

Answer 3

Promise.resolve().then(/* 1. */() => {
    setTimeout(/* 4. */() => {
        console.log("1") /* 8. */
     }, 0)
    /* 5. */
})


setTimeout(/* 2. */() => {
    console.log("2") /* 6. */
    /* 7. */
}, 0)
/* 3. */

1. 将以下任务添加到Microtask队列中。让我们称其为“ micro1”：

    （）=＆gt; {
       settimeout（（）=＆gt; {
           console.log（“ 1”）
       }，0）
   }
    

   任务队列看起来像

   • micro：[micro1]
   • 宏：[]

2. 安排以下宏观施法。让我们称其为“ Macro1”

    （）=＆gt; {
       console.log（“ 2”）
   }
    

   任务队列看起来像：

   • micro：[micro1]
   • 宏：[Macro1]

3. 代码完成执行。事件循环选择下一个任务。 Microtask队列具有优先级，下一个要执行的任务是Micro1。

4. 安排以下大型射击。让我们称其为“ macro2”

    （）=＆gt; {
       console.log（“ 1”）
   }
    

   超时为零，因此无需等待。队列首先是首先，因此，任务Macro2被添加到末端。没有更高的优先级仅仅是因为它来自微型箱或类似的东西。

   任务队列看起来像：

   • micro：[]
   • 宏：[Macro1，Macro2]

5. 任务完成执行。事件循环选择下一个任务。 MicroTask队列是空的，因此它从Macrotask队列中挑选任务。执行的下一个任务是Macro1。

6. 任务打印“ 2”到控制台。

7. 任务完成执行。事件循环选择下一个任务。 MicroTask队列是空的，因此它从Macrotask队列中挑选任务。执行的下一个任务是Macro2。

8. 任务打印“ 1”到控制台。