Async JavaScript - Glossaire

Ce glossaire regroupe les termes essentiels de la programmation asynchrone en JavaScript. Chaque définition est courte, concrète, et renvoie vers l'article de la serie qui approfondit le sujet. Garde cette page en favori -- c'est ma référencé quand un terme m'echappe.

Prerequisites

Aucun. Ce glossaire fonctionne comme référencé independante. Tu peux aussi l'utiliser en complement de n'importe quel article de la serie Async JavaScript en profondeur.

AbortController

Objet natif du navigateur et de Node.js qui permet d'annuler des opérations asynchrones (fetch, event listeners, streams). Tu créés un AbortController, tu passes son signal a l'opération, et tu appelles controller.abort() pour l'annuler. L'opération rejetee leve une AbortError. Voir : 11 - AbortController

async/await

Syntaxe introduite en ES2017 pour écrire du code asynchrone qui ressemble a du synchrone. async devant une fonction la fait retourner une Promise. await met en pause l'exécution de la fonction jusqu'a la résolution de la Promise. Sous le capot, c'est du sucre syntaxique sur les Promises et les generators. Voir : 03 - async/await

Backpressure

Mecanisme de contrôle de flux quand un producteur généré des donnees plus vite que le consommateur ne peut les traiter. En Streams API, le backpressure ralentit automatiquement le ReadableStream quand le WritableStream est sature. Sans backpressure, la mémoire explose. Voir : 10 - Streams

Call stack (pile d'appels)

Structure de donnees LIFO (Last In, First Out) ou le moteur JavaScript empile les frames d'exécution. Chaque appel de fonction ajoute une frame, chaque retour en retire une. Quand la stack est vide, l'event loop peut traiter le prochain message en file. Voir : 05 - Event loop

Callback

Fonction passee en argument a une autre fonction, exécutée plus tard (généralement quand une opération asynchrone se termine). C'est le mecanisme async originel de JavaScript. Les callbacks imbriques creent le "callback hell", résolu par les Promises. Voir : 01 - Callbacks

Callback hell

Imbrication profonde de callbacks qui rend le code illisible et difficile a maintenir. Aussi appele "pyramid of doom" a cause de l'indentation en escalier. Les Promises et async/await ont ete créés spécifiquement pour résoudre ce problème. Voir : 01 - Callbacks

Concurrency (concurrence)

Capacite a gerer plusieurs taches en cours simultanément, meme si elles ne s'executent pas physiquement en parallèle. JavaScript est concurrent grâce à l'event loop : il alterne entre les taches. A ne pas confondre avec le parallélisme (exécution simultanee sur plusieurs coeurs). Voir : 12 - Concurrence

Debounce

Technique qui retarde l'exécution d'une fonction jusqu'a ce qu'un delai se soit ecoule sans nouvel appel. Si la fonction est rappelée avant la fin du delai, le timer repart. Utilise pour les champs de recherche, le redimensionnement de fenêtre, etc. Exemple : l'utilisateur tape "javascript" -- la recherche ne se lance que 300ms apres la dernière lettre.

Event loop (boucle d'événements)

Mecanisme central de JavaScript qui orchestre l'exécution du code. Elle vérifié en boucle si la call stack est vide, puis depile les messages des files (microtask queue en priorité, puis macrotask queue). C'est elle qui rend JavaScript non-bloquant malgre son thread unique. Voir : 05 - Event loop

Executor

La fonction passee au constructeur new Promise(executor). Elle recoit deux arguments : resolve et reject. L'executor s'exécuté synchronement (immédiatement) a la création de la Promise. Voir : 02 - Promises

for-await-of

Boucle qui itéré sur un itérable asynchrone (comme un async generator ou un ReadableStream). A chaque itération, elle attend la résolution de la Promise produite avant de passer a la suivante. Voir : 13 - Generators

Generator (generateur)

Fonction déclarée avec function* qui peut se suspendre via yield et reprendre via next(). Produit un itérateur paresseux. La variante async function* combine generators et Promises pour les flux asynchrones. Voir : 13 - Generators

Macrotask

Tache planifiee dans la file principale de l'event loop. Exemples : setTimeout, setInterval, I/O callbacks, rendu. Chaque tour de boucle traite une macrotask, puis vide la file des microtasks, puis effectue le rendu si nécessaire. Voir : 06 - Microtasks vs macrotasks

Microtask

Tache de haute priorité exécutée entre les macrotasks. Exemples : callbacks .then() / .catch() / .finally(), queueMicrotask(), MutationObserver. La file des microtasks est videe complètement avant de passer a la macrotask suivante. Voir : 06 - Microtasks vs macrotasks

Mutex (mutual exclusion)

Mecanisme de synchronisation qui garantit qu'une seule tache a la fois accede a une ressource partagee. JavaScript n'a pas de mutex natif (pas besoin dans un thread unique), mais SharedArrayBuffer + Atomics permettent d'en implementer entre Workers. Voir : 12 - Concurrence

Promise

Objet representant le résultat futur d'une opération asynchrone. Une Promise est dans l'un de trois états : pending (en cours), fulfilled (résolue avec une valeur), ou rejected (rejetee avec une raison). Une fois settlee (fulfilled ou rejected), elle ne change plus d'état. Voir : 02 - Promises

Promise.all

Combinateur qui prend un itérable de Promises et retourne une Promise résolue avec un tableau de résultats. Si une seule Promise est rejetee, Promise.all est immédiatement rejetee. Utilise pour paralleliser des opérations independantes. Voir : 04 - Combinateurs

Promise.allSettled

Combinateur qui attend que toutes les Promises soient resolues ou rejetees. Retourne un tableau d'objets { status, value } ou { status, reason }. Ne rejette jamais. Utile quand tu veux les résultats de toutes les opérations, meme les échecs. Voir : 04 - Combinateurs

Promise.any

Combinateur qui retourne la première Promise résolue. Ignore les rejections tant qu'au moins une reussit. Si toutes sont rejetees, leve une AggregateError. Utile pour les stratégies de fallback (essayer plusieurs sources). Voir : 04 - Combinateurs

Promise.race

Combinateur qui retourne la première Promise settlee (résolue OU rejetee). Utilise pour les timeouts : faire la course entre une opération et un setTimeout qui rejette. Voir : 04 - Combinateurs

queueMicrotask

Fonction globale qui planifie une microtask. Plus explicite et leger que Promise.resolve().then(fn). La microtask sera exécutée apres la tache courante, avant le prochain rendu et avant la prochaine macrotask. Voir : 06 - Microtasks vs macrotasks

Race condition

Situation ou le résultat depend de l'ordre imprevisible d'opérations concurrentes. Exemple classique : deux requêtes fetch lancees, la deuxieme arrive avant la première, l'interface affiche des donnees obsolètes. Se resout avec AbortController, des flags, ou des verrous logiques. Voir : 09 - Patterns avances

requestAnimationFrame (rAF)

Méthode du navigateur qui planifie un callback juste avant le prochain rendu (typiquement 60fps). Indispensable pour les animations fluides. Le callback recoit un timestamp haute precision. Preferable a setInterval pour tout ce qui touche au visuel. Voir : 14 - rAF et rIC

requestIdleCallback (rIC)

Méthode du navigateur qui planifie un callback quand le navigateur est inactif (entre les frames). Le callback recoit un objet deadline avec timeRemaining(). Utilise pour les taches de fond non critiques : analytics, pre-chargement, nettoyage. Voir : 14 - rAF et rIC

Semaphore

Mecanisme de synchronisation qui limite le nombre d'acces concurrents a une ressource. Contrairement au mutex (limite a 1), un semaphore autorise N acces simultanees. En JavaScript, on l'implemente pour limiter la concurrence de requêtes réseau. Voir : 12 - Concurrence

setImmediate

Fonction Node.js qui planifie un callback a la fin de la phase de polling de l'event loop, avant les timers. Plus rapide que setTimeout(fn, 0) dans certains contextes Node.js. N'existe pas dans les navigateurs (sauf IE, ironiquement). Voir : 05 - Event loop

setTimeout / setInterval

Fonctions de planification de macrotasks. setTimeout(fn, ms) exécuté fn apres au moins ms millisecondes. setInterval(fn, ms) répété l'exécution. Le delai est un minimum, pas une garantie : si la call stack est occupee, le callback attend. Voir : 05 - Event loop

Stack frame

Unite dans la call stack representant un appel de fonction. Contient les variables locales, les arguments, et l'adresse de retour. Chaque await depile la frame en cours (la fonction se suspend), et une microtask la reempilera a la reprise. Voir : 05 - Event loop

Stack overflow

Erreur lancee quand la call stack dépassé sa taille maximale (généralement ~10 000 frames). Cause classique : recursion infinie. En asynchrone, await ou setTimeout dans une recursion évité le stack overflow car chaque appel passe par l'event loop (la stack est videe entre les itérations). Voir : 05 - Event loop

Starvation

Situation ou une file de taches ne progresse jamais parce qu'une file de priorité supérieure accapare le thread. Exemple : une boucle infinie de microtasks qui empecherait les macrotasks (et donc le rendu) de s'exécuter. En pratique, c'est rare mais possible avec queueMicrotask en boucle. Voir : 06 - Microtasks vs macrotasks

Thenable

Tout objet qui possede une méthode .then(). Les Promises sont des thenables, mais tous les thenables ne sont pas des Promises. Promise.resolve() et await acceptent les thenables et les convertissent en vraies Promises. Utile pour l'interop entre librairies. Voir : 02 - Promises

Throttle

Technique qui limite la fréquence d'exécution d'une fonction a une fois par intervalle de temps. Contrairement au debounce qui attend la fin de l'activité, le throttle garantit une exécution régulière pendant l'activité. Utilise pour le scroll, le resize, les requêtes API rate-limitees.

Top-level await

Syntaxe ES2022 qui permet d'utiliser await directement a la racine d'un module ESM. Le module devient implicitement asynchrone, et les modules qui l'importent attendent sa résolution. Pratique pour la config et les connexions, dangereux si mal utilise (bloque le graphe de modules). Voir : 15 - Top-level await

Unhandled rejection

Promise rejetee dont la rejection n'est capturee par aucun .catch() ou try/catch. Declenche l'événement unhandledrejection dans le navigateur et un warning (ou crash) dans Node.js. Toujours ajouter un .catch() ou un try/catch autour des await. Voir : 07 - Gestion d'erreurs

Web Worker

Thread d'exécution séparé du thread principal du navigateur. Communique par messages (postMessage / onmessage). N'a pas acces au DOM. Utilise pour le calcul lourd sans bloquer l'interface. Les SharedWorker et ServiceWorker sont des variantes specialisees. Voir : 12 - Concurrence

yield

Mot-clé utilise dans un generator (function*) pour produire une valeur et suspendre l'exécution. L'exécution reprend au prochain appel de next(). La valeur passee a next(val) devient la valeur de retour du yield. Dans un async generator, yield peut etre combine avec await. Voir : 13 - Generators

Ce glossaire couvre les termes rencontres dans les 18 articles de la serie. Si un terme manque ou si une définition merite d'etre precisee, ca se discute. Tu as tout ce qu'il faut pour relire n'importe quel article sans buter sur le vocabulaire.

Retrouve la serie complète et d'autres articles sur paltemps.fr.

Navigation : Precedent : 17 - Performance

Sources

MDN - Glossary: Asynchronous par Mozilla
ECMAScript 2023 Language Spécification par TC39
HTML Standard - Event loops par WHATWG