diff --git a/1-js/11-async/07-microtask-queue/article.md b/1-js/11-async/07-microtask-queue/article.md index 7691ba3b..067bbd18 100644 --- a/1-js/11-async/07-microtask-queue/article.md +++ b/1-js/11-async/07-microtask-queue/article.md @@ -3,9 +3,9 @@ Promise handlers `.then`/`.catch`/`.finally` are always asynchronous. -Even when a Promise is immediately resolved, the code on the lines *below* `.then`/`.catch`/`.finally` will still execute before these handlers . +Even when a Promise is immediately resolved, the code on the lines *below* `.then`/`.catch`/`.finally` will still execute before these handlers. -Here's the demo: +Here's a demo: ```js run let promise = Promise.resolve(); @@ -23,14 +23,14 @@ Why did the `.then` trigger afterwards? What's going on? ## Microtasks queue -Asynchronous tasks need proper management. For that, the standard specifies an internal queue `PromiseJobs`, more often referred to as "microtask queue" (v8 term). +Asynchronous tasks need proper management. For that, the Ecma standard specifies an internal queue `PromiseJobs`, more often referred to as the "microtask queue" (ES8 term). -As said in the [specification](https://tc39.github.io/ecma262/#sec-jobs-and-job-queues): +As stated in the [specification](https://tc39.github.io/ecma262/#sec-jobs-and-job-queues): - The queue is first-in-first-out: tasks enqueued first are run first. - Execution of a task is initiated only when nothing else is running. -Or, to say that simply, when a promise is ready, its `.then/catch/finally` handlers are put into the queue. They are not executed yet. When the JavaScript engine becomes free from the current code, it takes a task from the queue and executes it. +Or, to say more simply, when a promise is ready, its `.then/catch/finally` handlers are put into the queue; they are not executed yet. When the JavaScript engine becomes free from the current code, it takes a task from the queue and executes it. That's why "code finished" in the example above shows first. @@ -38,7 +38,7 @@ That's why "code finished" in the example above shows first. Promise handlers always go through this internal queue. -If there's a chain with multiple `.then/catch/finally`, then every one of them is executed asynchronously. That is, it first gets queued, and executed when the current code is complete and previously queued handlers are finished. +If there's a chain with multiple `.then/catch/finally`, then every one of them is executed asynchronously. That is, it first gets queued then executed when the current code is complete and previously queued handlers are finished. **What if the order matters for us? How can we make `code finished` run after `promise done`?** @@ -58,7 +58,7 @@ Remember the `unhandledrejection` event from the chapter alert('caught')); window.addEventListener('unhandledrejection', event => alert(event.reason)); ``` -...But if we forget to add `.catch`, then, after the microtask queue is empty, the engine triggers the event: +But if we forget to add `.catch`, then after the microtask queue is empty, the engine triggers the event: ```js run let promise = Promise.reject(new Error("Promise Failed!")); @@ -93,20 +93,20 @@ setTimeout(() => promise.catch(err => alert('caught')), 1000); window.addEventListener('unhandledrejection', event => alert(event.reason)); ``` -Now, if you run it, we'll see `Promise Failed!` first and then `caught`. +Now if we run it, we'll see `Promise Failed!` first and then `caught`. -If we didn't know about the microtasks queue, we could wonder: "Why did `unhandledrejection` handler run? We did catch the error!". +If we didn't know about the microtasks queue, we could wonder: "Why did `unhandledrejection` handler run? We did catch and handle the error!" -But now we understand that `unhandledrejection` is generated when the microtask queue is complete: the engine examines promises and, if any of them is in "rejected" state, then the event triggers. +But now we understand that `unhandledrejection` is generated once the microtask queue is complete. The engine examines promises and, if any of them is in the "rejected" state, then the event triggers. -In the example above, `.catch` added by `setTimeout` also triggers, but later, after `unhandledrejection` has already occurred, so that doesn't change anything. +In the example above, `.catch` added by `setTimeout` also triggers. But it does so later, after `unhandledrejection` has already occurred, so it doesn't change anything. ## Summary -Promise handling is always asynchronous, as all promise actions pass through the internal "promise jobs" queue, also called "microtask queue" (v8 term). +Promise handling is always asynchronous, as all promise actions pass through the internal "promise jobs" queue, also called "microtask queue" (ES8 term). -So, `.then/catch/finally` handlers are always called after the current code is finished. +So `.then/catch/finally` handlers are always called after the current code is finished. If we need to guarantee that a piece of code is executed after `.then/catch/finally`, we can add it into a chained `.then` call. -In most Javascript engines, including browsers and Node.js, the concept of microtasks is closely tied with "event loop" and "macrotasks". As these have no direct relation to promises, they are covered in another part of the tutorial, in the chapter . +In most Javascript engines, including browsers and Node.js, the concept of microtasks is closely tied with the "event loop" and "macrotasks". As these have no direct relation to promises, they are covered in another part of the tutorial, in the chapter .