Merge pull request #109 from TevaHenry/microtaches

Microtasks

Author: HachemiH

1-js/11-async/07-microtask-queue/article.md

@@ -1,78 +1,78 @@
 
-# Microtasks
+# Les microtaches
 
-Promise handlers `.then`/`.catch`/`.finally` are always asynchronous.
+Les gestionnaires de promesses `.then`/`.catch`/`.finally` sont toujours asynchrones.
 
-Even when a Promise is immediately resolved, the code on the lines *below* `.then`/`.catch`/`.finally` will still execute before these handlers .
+Même lorsqu'une promesse est immédiatement résolue, le code sur les lignes situées *ci-dessous* `.then`/`.catch`/`.finally` sera toujours exécuté avant ces gestionnaires.
 
-Here's the demo:
+Voici la démo:
 
 ```js run
 let promise = Promise.resolve();
 
 promise.then(() => alert("promise done!"));
 
-alert("code finished"); // this alert shows first
+alert("code finished"); // cette alerte s'affiche d'abord
 ```
 
-If you run it, you see `code finished` first, and then `promise done!`.
+Si vous exécutez, vous voyez `code finished` d'abord, puis `promise done!`.
 
-That's strange, because the promise is definitely done from the beginning.
+C'est étrange, car la promesse est certainement résolue depuis le début.
 
-Why did the `.then` trigger afterwards? What's going on?
+Pourquoi le `.then` se déclenche par la suite? Que se passe-t-il?
 
-## Microtasks queue
+## File d'attente pour microtaches
 
-Asynchronous tasks need proper management. For that, the standard specifies an internal queue `PromiseJobs`, more often referred to as "microtask queue" (v8 term).
+Les tâches asynchrones nécessitent une gestion appropriée. Pour cela, la norme spécifie une file d'attente interne `PromiseJobs`, plus souvent appelée "microtask queue" en anglais (terme v8).
 
-As said in the [specification](https://tc39.github.io/ecma262/#sec-jobs-and-job-queues):
+Comme indiqué dans la [spécification](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.
+- La file d'attente est premier entré, premier sorti: les tâches mises en file d'attente en premier sont exécutées en premier.
+- L'exécution d'une tâche est lancée uniquement lorsque rien d'autre n'est en cours d'exécution.
 
-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. JavaScript engine takes a task from the queue and executes it, when it becomes free from the current code.
+Ou, simplement, lorsqu'une promesse est prête, ses gestionnaires `.then/catch/finally` sont mis en file d'attente. Ils ne sont pas encore exécutés. Le moteur JavaScript extrait une tâche de la file d'attente et l'exécute lorsqu'elle est libérée du code actuel.
 
-That's why "code finished" in the example above shows first.
+C'est pourquoi "code finished" dans l'exemple ci-dessus s'affiche en premier.
 
 ![](promiseQueue.svg)
 
-Promise handlers always go through that internal queue.
+Les gestionnaires de promesses passent toujours par cette file d'attente interne.
 
-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.
+S'il existe une chaîne avec plusieurs `.then/catch/finally`, chacun d'entre eux est exécuté de manière asynchrone. C'est-à-dire qu'il est d'abord mis en file d'attente et exécuté lorsque le code actuel est terminé et que les gestionnaires précédemment placés en file d'attente sont terminés.
 
-**What if the order matters for us? How can we make `code finished` work after `promise done`?**
+**Et si l'order importait pour nous? Comment pouvons-nous faire en sorte que `code finished` s'exécute après `promise done`?**
 
-Easy, just put it into the queue with `.then`:
+Facile, il suffit de le mettre dans la file d'attente avec `.then`:
 
 ```js run
 Promise.resolve()
   .then(() => alert("promise done!"))
   .then(() => alert("code finished"));
 ```
 
-Now the order is as intended.
+Maintenant, l'ordre est comme prévu.
 
-## Unhandled rejection
+## Rejet non traité
 
-Remember `unhandledrejection` event from the chapter <info:promise-error-handling>?
+Souvenez-vous de l'événement `unhandledrejection` du chapitre <info:promise-error-handling>?
 
-Now we can see exactly how JavaScript finds out that there was an unhandled rejection
+Maintenant, nous pouvons voir exactement comment JavaScript découvre qu'il y a eu un rejet non géré
 
-**"Unhandled rejection" occurs when a promise error is not handled at the end of the microtask queue.**
+**Un rejet non traité se produit lorsqu'une erreur de promesse n'est pas traitée à la fin de la file d'attente des microtaches.**
 
-Normally, if we expect an error, we add `.catch` to the promise chain to handle it:
+Normalement, si nous nous attendons à une erreur, nous ajoutons `.catch` dans la chaîne de promesse pour la gérer:
 
 ```js run
 let promise = Promise.reject(new Error("Promise Failed!"));
 *!*
 promise.catch(err => alert('caught'));
 */!*
 
-// doesn't run: error handled
+// n'exécute pas: erreur gérée
 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:
+...Mais si nous oublions d’ajouter `.catch`, le moteur déclenche l’événement une fois que la file d’attente de microtaches est vide:
 
 ```js run
 let promise = Promise.reject(new Error("Promise Failed!"));
@@ -81,7 +81,7 @@ let promise = Promise.reject(new Error("Promise Failed!"));
 window.addEventListener('unhandledrejection', event => alert(event.reason));
 ```
 
-What if we handle the error later? Like this:
+Et si nous gérons l'erreur plus tard? Comme ceci:
 
 ```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!` message first, and then `caught`. 
+Maintenant, si vous l'exécutez, nous verrons d'abord le message `Promise Failed!`, Puis `caught`.
 
-If we didn't know about microtasks queue, we could wonder: "Why did `unhandledrejection` handler run? We did catch the error!".
+Si nous ne connaissions pas la file d'attente des microtaches, nous pourrions nous demander: "Pourquoi le gestionnaire `unhandledrejection` a-t-il été exécuté? Nous avons détecté l'erreur!".
 
-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.
+Mais nous comprenons maintenant que `unhandledrejection` est généré à la fin de la file d'attente des microtaches: le moteur examine les promesses et, si l'une d'entre elles est à l'état "rejected", l'événement se déclenche.
 
-In the example above, `.catch` added by `setTimeout` also triggers, but later, after `unhandledrejection` has already occurred, so that doesn't change anything.
+Dans l'exemple ci-dessus, `.catch` ajouté par `setTimeout` se déclenche également, mais plus tard, après que `unhandledrejection` se soit déjà produit, cela ne change rien.
 
-## Summary
+## Résumé
 
-Promise handling is always asynchronous, as all promise actions pass through the internal "promise jobs" queue, also called "microtask queue" (v8 term).
+Le traitement des promesses est toujours asynchrone, car toutes les actions de promesse passent par la file d'attente interne "promise jobs", également appelée "file d'attente pour microtaches" (terme v8).
 
-So, `.then/catch/finally` handlers are always called after the current code is finished.
+Ainsi, les gestionnaires `.then/catch/finally` sont toujours appelés une fois le code actuel terminé.
 
-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.
+Si nous devons garantir qu'un morceau de code est exécuté après `.then/catch/finally`, nous pouvons l'ajouter à un appel `.then` enchaîné.
 
-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 <info:event-loop>.
+Dans la plupart des moteurs Javascript, y compris les navigateurs et Node.js, le concept de microtaches est étroitement lié à la "boucle d'événement" et aux "macrotaches". Comme elles n’ont pas de relation directe avec les promesses, elles sont décrites dans une autre partie du didacticiel, au chapitre <info:event-loop>.