Un clic, et rien ne se passe pendant un tiers de seconde. Le bouton ne s'enfonce pas, le curseur ne clignote plus, l'animation s'arrête net. Ce n'est pas que le JavaScript soit lent : c'est qu'il garde la main. Une page web n'a qu'un fil principal, et tant qu'une tâche l'occupe, rien d'autre n'y passe — ni la réponse au clic, ni l'image suivante.
À 60 Hz, l'écran attend une nouvelle image toutes les 16,7 ms ; à 120 Hz, toutes les 8,3 ms. C'est le budget, et tout ce qui le dépasse se voit.
Un tour de boucle
Le navigateur fait tourner une boucle, que décrit la norme HTML. À chaque tour :
- il prend une tâche dans une file — un clic, un minuteur, la réponse d'un
fetch— et l'exécute jusqu'au bout ; - il vide toutes les microtâches : les suites de promesses,
queueMicrotask, lesMutationObserver; - s'il est temps de peindre une image, il exécute les rappels de
requestAnimationFrame, recalcule le style, la mise en page, et peint.
requestAnimationFrame (rAF), le style, la mise en page et la peinture.Deux conséquences. Une tâche ne s'interrompt jamais : le JavaScript va jusqu'au bout de la fonction, quoi qu'il arrive à l'écran. Et le rendu ne passe qu'entre deux tâches : une tâche de 300 ms, ce sont 300 ms sans image.
Les microtâches ont une particularité : leur file est vidée entièrement, y
compris des microtâches ajoutées pendant qu'on la vide. Une chaîne de promesses
qui se relance sans fin ne rend jamais la main au rendu, et la page gèle — là où
une chaîne de setTimeout laisserait passer les images.
// Gèle la page : la file des microtâches ne se vide jamais.
function geler() {
Promise.resolve().then(geler);
}
// Ne gèle pas : chaque relance est une nouvelle tâche, le rendu passe entre deux.
function respirer() {
setTimeout(respirer, 0);
}Ce que coûte une tâche longue
Une tâche de plus de 50 ms est dite longue : c'est le seuil des outils de mesure, celui au-delà duquel une interaction commence à se sentir. Son coût n'est pas seulement le temps qu'elle prend, c'est tout ce qu'elle retient. Un clic arrivé pendant la tâche attend qu'elle finisse, puis sa réponse attend l'image suivante.
C'est exactement ce que mesure l'INP (Interaction to Next Paint), l'indicateur de réactivité des Core Web Vitals : le temps entre une interaction et l'image qui en montre l'effet. Google le juge bon sous 200 ms, mauvais au-delà de 500. Une seule tâche de 130 ms en consomme plus de la moitié.
Le même travail, découpé, prend un peu plus longtemps au total : chaque reprise a un coût. Mais la page reste vivante. Chaque image est peinte, et le clic est servi entre deux morceaux.
Rendre la main
Découper un long travail, c'est lui faire rendre la main au navigateur à intervalles réguliers :
async function traiter(lignes: Ligne[]) {
let depuis = performance.now();
for (const ligne of lignes) {
calculer(ligne);
// Toutes les 10 ms, on laisse passer le rendu et les clics.
if (performance.now() - depuis > 10) {
await rendreLaMain();
depuis = performance.now();
}
}
}
function rendreLaMain(): Promise<void> {
// scheduler.yield() reprend en priorité, devant les tâches en attente.
if ("scheduler" in globalThis && "yield" in scheduler) return scheduler.yield();
return new Promise((resolve) => setTimeout(resolve, 0));
}scheduler.yield() existe dans Chromium depuis 2024 ; ailleurs, le repli sur
setTimeout fait l'affaire, avec une nuance : la suite repasse en fin de file,
derrière les autres tâches. Et setTimeout(fn, 0) n'attend jamais vraiment
zéro : après cinq relances imbriquées, la norme impose au moins 4 ms.
Pour toucher à l'affichage, le bon moment est requestAnimationFrame : son
rappel s'exécute juste avant le style et la mise en page de l'image à venir. Une
animation qui s'en sert peint au rythme de l'écran ; une animation menée par
setTimeout(…, 16) dérive, tombe parfois entre deux images, et en peint deux
d'un coup. Dans un onglet caché, requestAnimationFrame s'arrête — une
animation n'a pas à tourner pour personne.
Sur ce site, une fourmi de Langton fait ainsi plus d'un million de pas par
image : à chaque requestAnimationFrame, elle calcule douze millisecondes, puis
rend la main. Le reste du budget sert à peindre.
Déléguer : les autres fils
Certains calculs ne se découpent pas, ou mal : une requête SQL, le décodage d'un fichier, un algorithme qui ne sait pas s'arrêter au milieu. Leur place est dans un Web Worker : un autre fil, sans accès au DOM, mais qui ne bloque jamais la page. On lui parle par messages.
// worker.ts
self.onmessage = (e: MessageEvent<string>) => {
const resultat = executer(e.data); // des secondes, s'il le faut
self.postMessage(resultat);
};
// La page
const worker = new Worker(new URL("./worker.ts", import.meta.url), { type: "module" });
worker.onmessage = (e) => afficher(e.data);
worker.postMessage("SELECT …");Un avantage de plus : un worker qui s'éternise se tue avec worker.terminate(),
ce qu'aucune fonction du fil principal ne permet. Une base SQLite compilée en
WebAssembly peut ainsi exécuter une requête de dix secondes sans figer la page,
et s'arrêter d'un clic.
Le navigateur a lui-même plusieurs fils. Le compositeur assemble les calques
que le fil principal lui transmet, et les confie au GPU. Une animation CSS de
transform ou d'opacity peut vivre entièrement chez lui : elle reste fluide
pendant que le fil principal est bloqué. Une animation de left, de width ou
de margin, elle, demande une mise en page à chaque image — sur le fil
principal, donc à la merci de la prochaine tâche longue.
La mise en page forcée
Dernier piège, le plus discret. Le navigateur repousse la mise en page jusqu'au
moment de peindre — sauf si le code la réclame avant. Lire offsetHeight,
getBoundingClientRect() ou scrollTop juste après avoir modifié le DOM
l'oblige à tout recalculer sur-le-champ. Dans une boucle, c'est une mise en page
par tour :
// Une mise en page forcée par carte : chaque lecture suit l'écriture du tour précédent.
for (const carte of cartes) {
carte.style.width = `${carte.offsetWidth + 10}px`;
}
// Une seule : toutes les lectures d'abord, toutes les écritures ensuite.
const largeurs = cartes.map((carte) => carte.offsetWidth);
cartes.forEach((carte, i) => (carte.style.width = `${largeurs[i] + 10}px`));L'onglet Performance des outils de développement signale ces mises en page forcées, avec la ligne de code qui les a déclenchées.
Quand une page gèle
| Symptôme | Cause probable | Remède |
|---|---|---|
| Le clic répond en retard | une tâche longue | découper, scheduler.yield() |
| La page gèle sans fin | une chaîne de microtâches | repasser par une tâche |
| Une animation saccade | elle anime des propriétés de mise en page | transform, opacity |
| Un calcul fige tout | trop lourd pour être découpé | un Web Worker |
| Une boucle sur le DOM rame | des mises en page forcées | lire d'abord, écrire ensuite |
Pour trouver la tâche coupable, l'onglet Performance de Chrome dessine chaque tâche du fil principal et marque d'un triangle rouge celles qui dépassent 50 ms. En production, l'API Long Animation Frames dit quel script a retenu chaque image trop longue.
En résumé
- Un seul fil principal : tant qu'une tâche tourne, ni clic ni image.
- Une image toutes les 16,7 ms à 60 Hz ; une tâche est longue au-delà de 50 ms.
- Les microtâches passent toutes avant le rendu : une chaîne sans fin gèle la page.
- On découpe et on rend la main :
scheduler.yield(), sinonsetTimeout. - Ce qui ne se découpe pas part dans un Web Worker.
- On anime
transformetopacity, que le compositeur sait faire seul. - On lit la mise en page avant d'écrire dans le DOM.