Presentation delay de l'INP : taille du DOM, calcul du layout et optimisation du rendu
Identifiez et corrigez les problèmes d'INP causés par le presentation delay
Partager
Problèmes d'Interaction to Next Paint (INP) causés par le presentation delay
Cette page fait partie de notre série sur l'Interaction to Next Paint (INP). L'INP mesure le temps total entre une interaction utilisateur et la mise à jour visuelle suivante. Le presentation delay est la troisième et dernière phase de l'INP, après l'input delay et le processing time. Si vous découvrez l'INP, commencez par lire notre guide pour identifier et corriger les problèmes d'INP.
En résumé : l'Interaction to Next Paint (INP) mesure le temps nécessaire à un utilisateur pour voir un changement visuel sur la page après une interaction. Cet INP se décompose en 3 composants : l'« input delay », le « processing time » et le « presentation delay ».
Le presentation delay est le principal contributeur au temps total d'INP, représentant environ 42 % du temps total d'INP en moyenne. Optimiser le pipeline de rendu et simplifier la structure HTML constituent le premier levier pour améliorer l'INP.
Presentation delay : vous avez déjà cliqué sur un bouton en vous demandant pourquoi le résultat tardait une fraction de seconde à s'afficher ? C'est l'Interaction to Next Paint (INP) en action. Le presentation delay est la dernière étape de l'interaction : il intervient après le traitement de votre clic, mais avant l'apparition du moindre changement visuel.
Comprendre le presentation delay
La présentation est la phase finale d'une interaction. Le presentation delay représente le temps nécessaire au navigateur pour afficher les mises à jour visuelles consécutives à l'interaction. Le presentation delay commence dès que les gestionnaires d'événements ont fini de s'exécuter et se termine lorsque la frame suivante (qui intègre les changements visuels) est peinte. Plusieurs facteurs l'influencent, notamment la complexité du layout, la taille du DOM et la charge de rendu nécessaire.

L'Interaction to Next Paint (INP) se divise en 3 sous-parties : « Input Delay », « Processing Time » et « Presentation Delay ».
Presentation delay et l'INP
Le presentation delay est la dernière phase de l'INP. En moyenne, il représente environ 42 % du temps total d'INP, ce qui en fait le premier contributeur aux interactions lentes.

Chez CoreDash, nous collectons des millions de points de données Core Web Vitals chaque heure. D'après ces données, le presentation delay représente 42 % de l'Interaction to Next Paint. C'est plus que le processing time (40 %) et nettement plus que l'input delay (18 %). Bien qu'il soit le premier contributeur, le presentation delay est souvent la phase la plus complexe à optimiser car elle touche au pipeline de rendu du navigateur plutôt qu'au code applicatif.
Exemple de presentation delay : imaginez que vous parcouriez un site e-commerce sur votre téléphone à la recherche d'une nouvelle paire de chaussures. Vous appuyez sur la photo d'un produit pour afficher les détails. Mais le téléphone commence à dater et a du mal à suivre. Vous appuyez sur l'image (Interaction). Le téléphone met un certain temps à traiter l'action et à préparer l'affichage (Processing Time). Le site doit ensuite afficher la nouvelle page avec la grande image et les détails. Enfin, il s'écoule un délai bien visible avant que les informations et l'image du produit n'apparaissent réellement à l'écran (Presentation Delay). Ce retard sur l'INP frustre l'utilisateur : voilà pourquoi il faut le corriger.
Qu'est-ce qui cause un presentation delay élevé ?
Le presentation delay englobe tout le travail effectué par le navigateur une fois les gestionnaires d'événements terminés et avant que les pixels n'apparaissent à l'écran. Cela comprend le recalcul des styles, le calcul du layout, le paint et le compositing. Plusieurs facteurs contribuent à un presentation delay élevé :
Taille importante du DOM
Un DOM volumineux ou profondément imbriqué constitue l'une des causes les plus courantes d'un presentation delay élevé. Chaque fois que le navigateur doit actualiser l'état visuel de la page après une interaction, il doit recalculer les styles, calculer le layout et repeindre les éléments concernés. Le coût de chacune de ces étapes est directement proportionnel au nombre de nœuds DOM affectés.
Google recommande de maintenir le DOM sous la barre des 1 400 éléments, avec une profondeur maximale de 32 niveaux et un maximum de 60 éléments enfants par nœud parent (voir l'audit de taille du DOM Lighthouse). Quand le DOM dépasse ces seuils, le navigateur passe nettement plus de temps à recalculer les styles et le layout après chaque interaction.
Prenons un exemple : un utilisateur clique sur un bouton qui active ou désactive une classe CSS sur un conteneur. Si ce conteneur compte 5 000 nœuds descendants, le navigateur doit recalculer les styles pour potentiellement chacun d'entre eux, même si seuls quelques éléments changent visuellement. Ce recalcul s'effectue de manière synchrone avant le prochain paint, ce qui augmente directement le presentation delay.
Pour des techniques concrètes de réduction du DOM, consultez notre guide pour corriger une taille excessive du DOM.
Travail de layout excessif
Le layout (aussi appelé « reflow ») est l'étape au cours de laquelle le navigateur calcule la position et les dimensions de chaque élément visible sur la page. Après une interaction qui modifie le DOM ou change des propriétés CSS affectant la géométrie (width, height, margin, padding, top, left), le navigateur doit calculer le layout avant de pouvoir peindre la frame mise à jour.
Deux mauvaises pratiques déplacent le layout à l'intérieur de votre gestionnaire d'événements. Ce layout forcé est comptabilisé dans le processing time ; seul le layout que le navigateur exécute après la fin du gestionnaire compte dans le presentation delay :
Le forced synchronous layout se produit lorsque le JavaScript lit une propriété de layout (comme offsetHeight ou getBoundingClientRect()) après une modification du DOM qui a invalidé le layout. Le navigateur est contraint d'exécuter le layout de manière synchrone, au sein du gestionnaire d'événements, pour renvoyer une valeur exacte. Ce calcul s'impute alors au processing time, mais tout layout ultérieur déclenché par d'autres modifications du DOM bascule dans le presentation delay.
Le layout thrashing correspond à l'alternance répétée d'écritures dans le DOM et de lectures de propriétés de layout dans une boucle. Chaque lecture force le navigateur à recalculer le layout, et chaque écriture l'invalide à nouveau. Cela peut engendrer des dizaines, voire des centaines de calculs de layout inutiles par interaction. Voici un exemple de layout thrashing et la façon de le corriger :
// BAD: Layout thrashing inside a loop
function resizeItems() {
const items = document.querySelectorAll('.item');
items.forEach(item => {
// Read (forces layout)
const parentWidth = item.parentElement.offsetWidth;
// Write (invalidates layout)
item.style.width = parentWidth + 'px';
});
}
// GOOD: Batch reads, then batch writes
function resizeItems() {
const items = document.querySelectorAll('.item');
// Read all values first
const widths = Array.from(items).map(
item => item.parentElement.offsetWidth
);
// Then write all values
items.forEach((item, i) => {
item.style.width = widths[i] + 'px';
});
} Client-side rendering dans les Single Page Applications
Le rendu côté client du HTML peut lourdement impacter le presentation delay, surtout dans les Single Page Applications (SPA). Lorsqu'une interaction utilisateur déclenche un changement de route ou une mise à jour importante de l'interface, le framework SPA doit :
- Exécuter l'algorithme de diff du virtual DOM pour déterminer ce qui a changé
- Appliquer les mutations DOM résultantes au DOM réel
- Déclencher le recalcul des styles et le layout pour tous les éléments touchés
- Peindre la frame mise à jour
Dans les applications React, le processus de réconciliation du virtual DOM fait partie du processing time, mais les mutations DOM qui en résultent et leur coût de rendu relèvent du presentation delay. Plus l'arbre de composants produit de nœuds DOM, plus la réconciliation et le travail de rendu ultérieur sont coûteux.
Pour limiter cela dans les applications React et Next.js :
- Utilisez
React.memo()pour éviter les re-renders inutiles des composants enfants recevant les mêmes props. - Utilisez
useDeferredValue()pour les valeurs déclenchant des re-renders coûteux, ce qui permet à React de prioriser les mises à jour plus urgentes. - Gardez des arbres de composants peu profonds. Les hiérarchies de composants profondément imbriquées génèrent un DOM lourdement imbriqué, ce qui alourdit à la fois la réconciliation et le rendu du navigateur.
- Utilisez des bibliothèques de virtualisation (comme
react-windowou@tanstack/react-virtual) pour les listes volumineuses, afin que le DOM ne contienne que les éléments visibles.
Réduire le presentation delay
Minimiser la taille du DOM
Le gain le plus net sur le presentation delay s'obtient en gardant un DOM léger :
- Supprimez les éléments HTML inutilisés, en particulier les divs conteneurs profondément imbriqués.
- Virtualisez les listes volumineuses (ne faites le rendu que des éléments visibles et d'un petit tampon).
- Aplatissez les structures profondément imbriquées dès que possible.
- Utilisez CSS Grid et Flexbox pour la mise en page plutôt que d'empiler des divs imbriqués.
// Virtualize long lists to reduce DOM size
// Before: 10,000 items in the DOM
<ul>
{allItems.map(item =>
<li key="{item.id}">{item.name}</li>)
}
</ul>
// After: only visible items in the DOM (using react-window)
import { FixedSizeList } from 'react-window';
<fixedsizelist height="{600}"
itemcount="{allItems.length}"
itemsize="{50}" width="100%">
{({ index, style }) => (
<div style="{style}">{allItems[index].name}</div>
)}
</fixedsizelist>
Utiliser content-visibility pour différer le rendu du contenu hors écran
La propriété CSS content-visibility indique au navigateur d'ignorer le rendu du contenu situé hors écran tant que l'utilisateur ne scrolle pas à proximité. Cela allège le travail de rendu lors des interactions en limitant le recalcul des styles et le layout à la partie visible de la page.
/* Apply content-visibility to sections below the fold */
.below-fold-section {
content-visibility: auto;
contain-intrinsic-size: auto 500px;
}
/* Apply to individual items in long lists */
.list-item {
content-visibility: auto;
contain-intrinsic-size: auto 80px;
} La propriété contain-intrinsic-size fournit une hauteur estimée afin que le navigateur calcule correctement la taille de la barre de défilement sans devoir faire le rendu du contenu. Cela évite les layout shifts lorsque l'utilisateur scrolle et que le contenu devient visible.
Pour découvrir d'autres stratégies d'optimisation CSS réduisant les coûts de rendu, consultez notre guide sur la suppression du CSS inutilisé.
Minimiser le travail de layout déclenché par les interactions
Lors de la conception des interactions, privilégiez les propriétés CSS qui ne déclenchent pas de layout. Les propriétés comme transform et opacity sont directement prises en charge par le compositeur GPU sans déclencher de layout ni de paint. Au lieu d'animer top, left, width ou height, utilisez transform: translate() et transform: scale(). Pour consulter la liste complète des propriétés CSS qui déclenchent un layout, consultez le guide des performances de rendu sur web.dev.
Utilisez la propriété CSS will-change pour signaler au navigateur qu'un élément va être animé. Cela permet au navigateur de créer un calque de composition séparé pour cet élément, isolant son rendu du reste de la page :
/* Promote elements to their own compositor layer */
.animated-element {
will-change: transform, opacity;
}
/* Toggle visibility with opacity instead of display */
.modal {
opacity: 0;
pointer-events: none;
transform: translateY(10px);
transition: opacity 0.2s, transform 0.2s;
}
.modal.active {
opacity: 1;
pointer-events: auto;
transform: translateY(0);
} Identifier les presentation delays trop longs
Pour identifier les presentation delays trop longs, vous pouvez utiliser le profileur de performance de Chrome. Ouvrez les DevTools (Ctrl+Shift+I), allez dans l'onglet Performance, lancez l'enregistrement et interagissez avec la page.
Vous pouvez ensuite analyser la timeline d'une interaction et visualiser ses différentes phases, y compris le presentation delay. En examinant les mises à jour de rendu qui surviennent après l'exécution des gestionnaires d'événements, vous pouvez identifier précisément les goulots d'étranglement responsables d'un long presentation delay. Recherchez les blocs volumineux « Recalculate Style », « Layout » et « Paint » dans la timeline : ils représentent le travail que le navigateur effectue durant la phase de presentation delay.

Identifier le presentation delay avec les données RUM
Mesurer le presentation delay avec les Long Animation Frames (LoAF)
L'API Long Animation Frames (LoAF) montre exactement ce qui cause les retards de rendu pendant les interactions utilisateur. L'API fournit des données de timing pour séparer le processing time du presentation delay et identifier précisément les scripts qui ralentissent le rendu.
Les propriétés clés de LoAF pour comprendre le presentation delay sont :
renderStart: début de la phase de rendu par le navigateur (recalcul des styles, layout, paint)styleAndLayoutStart: début du calcul des styles et du layoutduration: durée totale de la long animation frameblockingDuration: part de la frame bloquée par les scripts
LoAF n'est actuellement disponible que sur Chromium (Chrome 123+). Pour les autres navigateurs, utilisez les traces du panneau Performance des DevTools Chrome pour analyser le travail de rendu.
La différence entre la fin de l'exécution des scripts et la fin de la frame représente le coût pur du rendu, c'est-à-dire le presentation delay. Voici comment observer et enregistrer ces données :
// Measure presentation delay using LoAF API
const observer = new PerformanceObserver((list) => {
for (const entry of list.getEntries()) {
if (entry.duration > 50) {
const scriptEnd = Math.max(
...entry.scripts.map(s => s.startTime + s.duration)
);
const presentationDelay = (
entry.startTime + entry.duration
) - Math.max(scriptEnd, entry.renderStart);
console.log('Presentation delay breakdown:', {
totalDuration: entry.duration,
renderStart: entry.renderStart,
styleAndLayoutStart: entry.styleAndLayoutStart,
estimatedPresentationDelay: presentationDelay,
scriptCount: entry.scripts.length
});
}
}
});
observer.observe({
type: 'long-animation-frame',
buffered: true
}); Les outils de RUM comme CoreDash intègrent les données LoAF et vous montrent quels scripts et quelles modifications du DOM provoquent des retards de rendu, avec une attribution complète des scripts.
Explorer les autres phases de l'INP
Pour maîtriser votre INP, traitez également les deux autres phases :
- Input Delay : minimisez le temps d'attente avant que les gestionnaires d'événements ne commencent à s'exécuter. L'input delay est généralement la phase la plus courte, mais il s'envole au démarrage de la page lorsque le main thread est occupé.
- Processing Time : optimisez le code des gestionnaires d'événements exécuté pendant l'interaction. Sur la plupart des pages, c'est là que l'essentiel de vos efforts d'optimisation porte ses fruits.
Pour un workflow de diagnostic complet, consultez notre guide pour identifier et corriger les problèmes d'INP. Pour d'autres stratégies d'optimisation du rendu, explorez nos guides sur la correction d'une taille excessive du DOM et la suppression du CSS inutilisé. Revenez à la page principale sur l'INP pour une vue d'ensemble complète.

Besoin d'un site plus rapide ?
Je suis Arjen et je répare des sites lents depuis 17 ans. Si vous rencontrez des problèmes que vous ne pouvez pas résoudre vous-même, envoyez-moi votre URL et parlons-en.
Envoyez-moi votre URL
Pourquoi notre fix ne fonctionne pas ?
Parfois le CDN sert encore l'ancien HTML, ou le fix a été appliqué sur le template desktop alors que le mobile en utilise un autre. Envoyez-moi votre URL et le problème, et je vous réponds avec quelques créneaux. J'analyse d'abord vos field data, puis nous passons une heure sur votre site, et sous 24 heures vous avez mes notes par écrit. 350 € HT.
Envoyez-moi votre URLPas de développeur pour réaliser le fix ? Je fais le travail moi-même, sur une copie de votre site.