Interaction to Next Paint (INP) : le guide complet
Optimisez l’Interaction to Next Paint (INP) pour améliorer la réactivité. Stratégies concrètes pour réduire le délai de saisie et le temps de traitement.
L'équipe Auditite
Sommaire
Qu'est-ce que l'Interaction to Next Paint (INP) ?
Interaction to Next Paint (INP) a remplacé le First Input Delay (FID) comme Core Web Vital en mars 2024. Alors que le FID ne mesurait que le délai avant que le navigateur ne commence à traiter la première interaction, l'INP mesure la réactivité complète de toutes les interactions tout au long du cycle de vie d'une page — du clic ou du tap de l'utilisateur jusqu'au moment où le navigateur affiche la mise à jour visuelle.
Seuils de Google :
- Bon : INP inférieur à 200 millisecondes
- À améliorer : 200 à 500 millisecondes
- Mauvais : plus de 500 millisecondes
L’INP est une métrique plus exigeante que le FID, car elle capture chaque interaction et pas seulement la première, et mesure le cycle complet : délai d’entrée, temps de traitement et délai de présentation.
Les trois phases de l’INP
Chaque interaction de l'utilisateur passe par trois phases :
1. Délai d'entrée
Le délai entre le moment où l’utilisateur interagit (clic, toucher ou appui sur une touche) et celui où le navigateur commence à exécuter le gestionnaire d’événements. Le délai d’entrée survient quand le thread principal est occupé par d’autres tâches (analyse de JavaScript, exécution de minuteurs, traitement d’autres événements).
2. Temps de traitement
Le temps passé à exécuter le code du gestionnaire d’événements. Les gestionnaires longs qui effectuent des calculs complexes, des manipulations du DOM ou des appels API synchrones allongent le temps de traitement.
3. Délai de présentation
Le temps écoulé entre la fin du gestionnaire d'événement et le moment où le navigateur affiche la mise à jour visuelle. Cela inclut le recalcul des styles, la mise en page et les opérations de rendu.
L'INP est la somme des trois phases pour l'interaction la plus lente (plus précisément, l'interaction au 98e centile).
Réduire le délai d'entrée
Découper les tâches longues
Le thread principal ne peut faire qu'une chose à la fois. Si une longue tâche JavaScript s'exécute au moment du clic, l'interaction doit attendre la fin de cette tâche. Les tâches longues (plus de 50 ms) sont la principale cause du délai d'entrée.
Solutions :
- Utilisez
requestIdleCallbackpour le travail non urgent - Découpez les tâches en morceaux plus petits avec
setTimeout(fn, 0)ouscheduler.postTask() - Utilisez des web workers pour les opérations de calcul intensif
- Différez le JavaScript non critique pour qu’il n’entre pas en concurrence avec les interactions des utilisateurs
Réduire l’impact des scripts tiers
Les scripts d’analytics, de widgets de chat et de publicité exécutent souvent des opérations lourdes sur le thread principal. Auditez vos scripts tiers et :
- Chargez-les après la première interaction avec la page
- Utilisez l'attribut
asyncoudefer - Envisagez d’utiliser un gestionnaire de balises avec chargement déclenché
- Supprimez les scripts qui apportent peu de valeur
Optimiser les écouteurs d’événements
Évitez d’ajouter des écouteurs d’événements sur des événements à haute fréquence (scroll, mousemove, resize) sans throttling ni debouncing. Ils peuvent saturer le thread principal et bloquer les autres interactions.
Réduire le temps de traitement
Optimiser le code des gestionnaires d'événements
Passez en revue vos gestionnaires de clics, soumissions de formulaires et autres codes interactifs pour détecter :
- Requêtes DOM inutiles — mettez en cache les références DOM au lieu de les interroger à chaque interaction
- Mutations DOM coûteuses : regroupez les modifications du DOM et utilisez
requestAnimationFramepour les mises à jour visuelles - Opérations synchrones : passez les lectures de fichiers, opérations de stockage et calculs à des modèles asynchrones
- Calculs redondants : mémoïsez les résultats qui ne changent pas entre les interactions
Utilisez des structures de données efficaces
Si vos gestionnaires d'événements traitent de gros volumes de données (filtrage, tri, recherche), utilisez des structures de données et des algorithmes adaptés. Une recherche linéaire parmi des milliers d'éléments à chaque frappe de touche génère un INP désastreux.
Éviter le layout thrashing
Lire des propriétés de mise en page (offsetHeight, getBoundingClientRect) puis écrire dans le DOM force le navigateur à recalculer la mise en page de façon synchrone. Ce schéma, appelé layout thrashing, augmente considérablement le temps de traitement.
Correction : regroupez toutes les lectures du DOM, puis toutes les écritures du DOM. Ou utilisez requestAnimationFrame pour séparer les cycles de lecture et d'écriture.
Réduire le délai de présentation
Simplifier les sélecteurs CSS
Les sélecteurs CSS complexes (profondément imbriqués, universels, sélecteurs d'attributs) ralentissent le recalcul des styles après les modifications du DOM. Gardez des sélecteurs simples et précis.
Réduire la taille du DOM
Les pages dotées d’arbres DOM volumineux (plus de 1 500 éléments) mettent plus de temps à recalculer les styles et la mise en page après une interaction. Simplifiez votre balisage et évitez les structures profondément imbriquées.
Utiliser CSS Containment
La propriété CSS contain indique au navigateur que les changements à l’intérieur d’un élément n’affectent pas les éléments extérieurs, ce qui lui permet d’optimiser les opérations de mise en page et de rendu :
.component {
contain: layout style;
}
Éviter les mises en page synchrones forcées
Comme pour le layout thrashing, tout code qui force le navigateur à terminer la mise en page avant de continuer (lecture de propriétés de layout après des modifications du DOM) augmente le délai de présentation.
Mesurer l'INP
Tests en laboratoire
L’INP est difficile à mesurer en environnement de laboratoire, car il dépend des interactions réelles des utilisateurs. Vous pouvez toutefois :
- Utilisez le panneau Performance de Chrome DevTools : enregistrez les interactions et mesurez le temps total de traitement des événements
- Utilisez les user flows Lighthouse — scriptez des interactions et mesurez la réactivité
- Tests manuels : parcourez votre site en surveillant le panneau Performance
Données de terrain
Les données terrain sont essentielles pour l’INP, car elles reflètent le comportement réel des utilisateurs :
- Chrome User Experience Report (CrUX) : données d’INP agrégées d’utilisateurs réels
- Google Search Console — le rapport Core Web Vitals inclut l’INP
- Bibliothèque JavaScript Web Vitals : mesurez l'INP auprès de vos propres utilisateurs
Identifier les pires interactions
Utilisez la bibliothèque Web Vitals avec attribution pour identifier précisément les interactions qui ont les pires scores INP :
- Quel élément a été sollicité
- Quel type d'interaction (clic, appui sur une touche, etc.)
- Durée de chaque phase (délai d’entrée, traitement, présentation)
Ces données vous indiquent précisément où concentrer vos efforts d'optimisation.
Optimisation de l’INP selon le framework
React
- Utilisez
useMemoetuseCallbackpour éviter les rendus inutiles - Mettez en place la virtualisation pour les longues listes (react-window, react-virtuoso)
- Utilisez
useTransitionpour marquer les mises à jour d'état non urgentes - Utilisez les fonctionnalités concurrentes (startTransition) pour garder l'interface réactive pendant les mises à jour lourdes
Vue
- Utilisez des propriétés calculées plutôt que des méthodes pour les données dérivées
- Mettez en place un défilement virtuel pour les longues listes
- Utilisez
v-oncepour le contenu qui ne change jamais - Chargez les composants en lazy loading avec
defineAsyncComponent
JavaScript natif
- Utilisez la délégation d'événements plutôt que des écouteurs individuels sur de nombreux éléments
- Mettez en place un debouncing pour les mises à jour déclenchées par la saisie
- Utilisez
requestAnimationFramepour les mises à jour visuelles - Découpez les opérations coûteuses en tronçons avec
scheduler.yield()
Checklist d’optimisation de l’INP
- Aucune tâche longue de plus de 50 ms sur le thread principal pendant les interactions
- Les scripts tiers sont chargés après le contenu critique
- Les gestionnaires d’événements s’exécutent en moins de 100 ms
- Pas de layout thrashing (mélange de lectures et d’écritures)
- La taille du DOM est inférieure à 1 500 éléments
- CSS containment appliqué aux composants indépendants
- INP terrain mesuré et surveillé avec des données d'utilisateurs réels
- Pires interactions identifiées et optimisées
À retenir
L'INP est le Core Web Vital le plus difficile à optimiser techniquement, car il touche tous les aspects de l'interactivité de votre site :
- Réduisez le délai d'entrée en découpant les longues tâches et en différant le JavaScript non critique
- Optimisez le temps de traitement en écrivant des gestionnaires d’événements efficaces et en évitant le layout thrashing
- Réduisez le délai de présentation grâce au confinement CSS, à des sélecteurs simplifiés et à des arbres DOM plus petits
- Mesurez avec de vrais utilisateurs — les données de laboratoire seules ne permettent pas de saisir toute la réalité de l'INP
- Concentrez-vous sur les pires interactions : votre interaction au 98e centile détermine votre score INP
Associé à de bons scores de LCP et de CLS, un INP optimisé garantit que votre site paraît rapide et réactif à chaque interaction de l'utilisateur.
Restez informé
Recevez des analyses, des stratégies et les nouveautés produit directement dans votre boîte de réception.
Pas de spam. Désabonnement à tout moment.
Prêt à voir Auditite en action ?
Lancez-vous et voyez comment Auditite peut transformer votre workflow d’audit SEO.
Commencer