JavaScript事件循环与同步执行顺序详解

编程并不是一个机械性的工作，而是需要有思考，有创新的工作，语法是固定的，但解决问题的思路则是依靠人的思维，这就需要我们坚持学习和更新自己的知识。今天golang学习网就整理分享《JavaScript事件循环与同步代码执行顺序解析》，文章讲解的知识点主要包括，如果你对文章方面的知识点感兴趣，就不要错过golang学习网，在这可以对大家的知识积累有所帮助，助力开发能力的提升。

JavaScript中同步代码的执行优先级最高，它会先被彻底执行完，之后事件循环才会处理异步任务。1.同步代码立即推入调用栈按先进后出顺序执行，是阻塞式的。2.异步任务如定时器、网络请求会被交给宿主环境处理，完成后回调放入任务队列。3.事件循环检查调用栈是否为空，若空则优先清空微任务队列（如Promise回调），再从宏任务队列（如setTimeout）取一个任务执行。4.微任务优先级高于宏任务，且每次事件循环周期中，所有微任务会在宏任务前被处理完。5.异步错误处理和流程控制推荐使用Promise结合async/await，前者通过.catch()捕获错误，后者通过try...catch实现更清晰的错误处理和顺序执行。6.对于无依赖的异步任务，可使用Promise.all()或Promise.race()并发执行，提高效率。

在JavaScript里，同步代码的执行优先级是最高的，它会先被彻底执行完。只有当同步任务都清空了，事件循环（Event Loop）才会开始检查并处理那些异步任务，比如定时器、网络请求的回调等等。这个过程保证了主线程的非阻塞性，让用户界面保持响应。

解决方案

理解JavaScript中代码的执行顺序，核心在于把握“同步优先，异步等待”的原则，以及事件循环如何协调这一切。当一段JavaScript代码开始执行时，所有同步代码会立即被推入调用栈（Call Stack），并按照先进后出的顺序依次执行。这是一个阻塞的过程，意味着只有当前同步任务完成后，下一个任务才能开始。

举个例子，你写的console.log('Hello');会立刻执行，因为它是个同步操作。但如果你发起一个网络请求fetch('/api/data')，这个请求本身是异步的。JS引擎会把这个请求交给浏览器（Web APIs）或Node.js环境去处理，而不是在主线程上等待结果。当网络请求完成并返回数据时，它的回调函数（比如.then()里的代码）并不会立刻执行，而是被放入一个“任务队列”（Task Queue，也叫消息队列或回调队列）中等待。

这里有个关键的区分：微任务队列（Microtask Queue）和宏任务队列（Macrotask Queue）。Promise的回调（.then(), .catch(), .finally()）、async/await（本质上也是Promise的语法糖）以及queueMicrotask产生的都是微任务。而像setTimeout, setInterval, I/O操作（如文件读写）、UI渲染事件等则属于宏任务。

事件循环（Event Loop）就像一个勤劳的调度员，它会不断地检查调用栈是否为空。一旦调用栈清空（意味着所有同步代码都执行完毕），事件循环会优先清空微任务队列中的所有任务，将它们依次推入调用栈执行。只有当微任务队列也清空后，事件循环才会从宏任务队列中取出一个任务（注意：每次循环只取一个），将其推入调用栈执行。这个宏任务执行完毕后，新一轮的事件循环又会开始，再次检查微任务队列，然后是宏任务队列，如此往复。

这个机制保证了JavaScript的单线程特性，同时又能够高效地处理大量的异步操作，避免了主线程长时间的阻塞。我常常觉得，理解事件循环就像理解一个餐厅的运营。同步代码是那些VIP客人，他们一来就得立刻上菜，不能等。异步任务就像是普通客人，需要等厨房（Web APIs）做好了，再由服务员（Event Loop）按顺序（队列）送过去。而微任务就像是餐厅的“插队特权”客户，他们比普通客人优先级更高，只要VIP客人走了，他们就能立刻被服务。

console.log('1. 同步任务开始');

setTimeout(() => {
  console.log('4. 宏任务：setTimeout');
}, 0);

Promise.resolve().then(() => {
  console.log('3. 微任务：Promise.then');
});

console.log('2. 同步任务结束');

// 执行顺序会是：
// 1. 同步任务开始
// 2. 同步任务结束
// 3. 微任务：Promise.then
// 4. 宏任务：setTimeout

为什么说JavaScript是单线程的，却能处理异步操作？

这是一个非常经典的问题，也是理解JavaScript运行机制的关键。JavaScript本身确实是单线程的，这意味着它只有一个调用栈（Call Stack），一次只能执行一个任务。所有的代码都在这一个主线程上运行，避免了多线程编程中常见的复杂性，比如死锁和资源竞争。

那么，既然是单线程，像网络请求、定时器、文件读写这些耗时的操作，如果都在主线程上执行，那岂不是会阻塞整个程序，导致用户界面卡死？这就是JavaScript设计巧妙的地方，它将这些耗时操作“外包”了。

具体来说，当JavaScript引擎遇到一个异步操作（比如setTimeout或fetch）时，它不会在主线程上等待这个操作完成。相反，它会将这个任务交给宿主环境（比如浏览器提供了Web APIs，Node.js提供了C++ APIs）去处理。这些Web APIs或Node.js APIs是在JS引擎的主线程之外独立运行的。

当这些外部操作完成时（比如定时器时间到了，或者网络请求返回了数据），它们会将对应的回调函数（也就是你写在setTimeout或fetch().then()里的代码）放入一个任务队列中。这个任务队列不是调用栈，它是一个等待区。

事件循环（Event Loop）就是连接主线程和这些任务队列的桥梁。它会不断地检查主线程的调用栈是否为空。一旦调用栈空了（表示所有同步任务都执行完了），事件循环就会从任务队列中取出最先进入的任务（或者根据优先级从微任务队列中取），然后将其推入调用栈，让主线程去执行。

所以，JavaScript的单线程特性保证了代码执行的顺序性和简单性，而异步操作的处理则通过宿主环境的协助和事件循环的调度来实现，这使得JavaScript能够以非阻塞的方式高效地处理并发任务。我个人觉得，这种设计理念非常优雅，它既保持了语言的简洁性，又赋予了它强大的并发处理能力。

Microtask Queue和Macrotask Queue的优先级差异体现在哪里？

微任务队列（Microtask Queue）和宏任务队列（Macrotask Queue）的优先级差异是事件循环中最核心、也最容易让人混淆的一个点。简单来说，微任务的优先级要高于宏任务，并且在一个事件循环周期内，所有的微任务都会在下一个宏任务开始之前被完全清空。

具体体现在：

1. 清空时机不同： 每当主线程的调用栈清空后，事件循环会首先检查并执行微任务队列中的所有任务。只有当微任务队列完全清空了，事件循环才会从宏任务队列中取出一个任务来执行。
2. “一次性”与“逐个”： 微任务队列是“一次性清空”的，也就是说，在当前宏任务执行完毕到下一个宏任务开始之间，所有新产生的微任务都会被立即执行。而宏任务队列则是“逐个执行”的，每次事件循环只从宏任务队列中取出一个任务来执行。

我们来看一个具体的例子来感受这种差异：

console.log('Start');

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

Promise.resolve().then(() => {
  console.log('Promise 1');
});

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

console.log('End');

// 实际输出顺序会是：
// Start
// End
// Promise 1
// setTimeout 1
// Promise inside setTimeout
// setTimeout 2

解析这个例子：

• 'Start' 和 'End' 是同步任务，会立即执行。
• setTimeout 1 和 setTimeout 2 是宏任务，被放入宏任务队列。
• Promise 1 是微任务，被放入微任务队列。

执行流程：

1. 同步阶段： console.log('Start') -> console.log('End')。此时调用栈清空。
2. 第一轮事件循环 - 微任务阶段： 调用栈清空后，事件循环会立即检查微任务队列，发现 Promise 1，将其推入调用栈执行 console.log('Promise 1')。微任务队列清空。
3. 第一轮事件循环 - 宏任务阶段： 微任务队列清空后，事件循环从宏任务队列中取出第一个任务，即 setTimeout 1 的回调。将其推入调用栈执行 console.log('setTimeout 1')。
   • 在 setTimeout 1 的回调中，又创建了一个微任务 Promise inside setTimeout，它会被立即添加到微任务队列中。
4. 第二轮事件循环 - 微任务阶段： setTimeout 1 回调执行完毕，调用栈再次清空。事件循环再次检查微任务队列，发现 Promise inside setTimeout，将其推入调用栈执行 console.log('Promise inside setTimeout')。微任务队列清空。
5. 第二轮事件循环 - 宏任务阶段： 微任务队列清空后，事件循环从宏任务队列中取出下一个任务，即 setTimeout 2 的回调。将其推入调用栈执行 console.log('setTimeout 2')。

这个例子清晰地展示了微任务如何在一个宏任务执行完毕后，但在下一个宏任务开始之前，被优先执行。理解这一点对于编写高并发、高性能的JavaScript代码至关重要，尤其是在处理用户界面更新或复杂的数据流时。

异步操作中的错误处理和流程控制有什么最佳实践？

在JavaScript的异步编程中，有效地处理错误和控制流程是保证应用健壮性和可维护性的关键。随着异步模式的演进，我们有了更优雅的解决方案。

1. 使用 Promise 进行错误处理和链式调用

Promise 是处理异步操作的基础，它提供了一种结构化的方式来管理异步代码的成功和失败。

• 错误处理： Promise.prototype.catch() 是专门用于捕获 Promise 链中任何地方发生的错误的。它比传统的 try...catch 更适用于异步代码，因为异步操作的错误通常发生在主线程之外。

  fetch('/api/data')
    .then(response => {
      if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`);
      }
      return response.json();
    })
    .then(data => console.log(data))
    .catch(error => console.error('Fetch error:', error)); // 集中捕获错误

• 流程控制： Promise 的链式调用（.then().then()）非常适合处理一系列顺序执行的异步操作。每个 .then() 返回一个新的 Promise，允许你将后续操作链接起来。

  function step1() {
    return new Promise(resolve => setTimeout(() => { console.log('Step 1 complete'); resolve('data1'); }, 500));
  }
  
  function step2(data) {
    return new Promise(resolve => setTimeout(() => { console.log(`Step 2 complete with ${data}`); resolve('data2'); }, 300));
  }
  
  step1()
    .then(result1 => step2(result1))
    .then(result2 => console.log(`Final result: ${result2}`))
    .catch(error => console.error('Error in chain:', error));

2. 借助 Async/Await 实现更简洁的流程控制和错误处理

async/await 是 ES2017 引入的语法糖，它建立在 Promise 之上，使得异步代码看起来和写起来都更像同步代码，极大地提高了可读性。

• 错误处理： async/await 允许你直接使用传统的 try...catch 语句来捕获异步操作中的错误，这让错误处理变得直观且熟悉。

  async function fetchData() {
    try {
      const response = await fetch('/api/non-existent-data');
      if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`);
      }
      const data = await response.json();
      console.log(data);
    } catch (error) {
      console.error('An error occurred:', error);
    }
  }
  fetchData();

• 流程控制： await 关键字会暂停 async 函数的执行，直到其后面的 Promise 解决（resolved）或拒绝（rejected）。这使得处理顺序依赖的异步操作变得非常简单和线性。

  async function processData() {
    try {
      console.log('Starting process...');
      const result1 = await step1(); // 等待 step1 完成
      const result2 = await step2(result1); // 等待 step2 完成
      console.log(`All steps completed with: ${result2}`);
    } catch (error) {
      console.error('Process failed:', error);
    }
  }
  processData();

最佳实践总结：

• 优先使用 async/await： 它让异步代码的可读性和可维护性达到最佳，特别是在处理多个顺序异步操作或需要复杂逻辑时。
• 始终捕获 Promise 错误： 无论是使用 .catch() 还是 try...catch，确保你的 Promise 链或 async 函数中的错误能够被妥善处理，避免出现未捕获的 Promise 拒绝（unhandled promise rejections），这在某些环境中可能会导致应用崩溃。
• 细粒度错误处理： 根据需要，可以在链的特定环节捕获并处理特定错误，也可以在最外层统一捕获。
• 避免回调地狱： 尽量使用 Promise 或 async/await 来替代嵌套过深的回调函数，以提高代码的可读性和可维护性。
• 考虑并发执行： 对于相互之间没有依赖的异步操作，可以使用 Promise.all()（等待所有 Promise 完成）或 Promise.race()（等待第一个 Promise 完成）来并行执行，提高效率。

我个人在实际项目中，几乎总是倾向于使用 async/await。它让异步代码的逻辑流变得非常清晰，就像读故事一样，一步一步往下走。而 try...catch 的模式也让错误处理变得异常直观，大大减少了调试异步问题时的心智负担。

本篇关于《JavaScript事件循环与同步执行顺序详解》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于文章的相关知识，请关注golang学习网公众号！