STATUS IS UPWIKI D'OPTIMISATION DE SITE
25Accélérer
Performance et livraison / Accélérer

Performances JavaScript : Réduire le travail sur le thread principal

Repérez le JavaScript qui ralentit une page, retarde des interactions ou exécute des traitements inutiles, puis protégez les parcours sensibles.

Performances JavaScript : Réduire le travail sur le thread principal — GUIDE VISUEL
LIRE
8 minutes
SOURCES
5
RÉVALIDER
2027-03-27
examiné
Relecteur ou relectrice senior en performances web
LA RÉPONSE COURTE

Commencez par la décision.

Réduisez le travail sur le thread principal en mesurant un parcours réel et une interaction, puis corrigez le coût répétable le plus important. Le thread principal exécute la plupart du JavaScript et des traitements d’interface de la page, une tâche à la fois. Une tâche de plus de 50 millisecondes est une tâche longue ; un appui, un clic, un défilement ou le rendu peuvent attendre qu’elle se termine. Commencez par le paiement, la recherche, la navigation, les formulaires et les autres parcours sensibles.

Pour chaque coût identifié, supprimez-le, différerez-le jusqu'à ce qu'il soit nécessaire, divisez-le en petits lots ou déplacez un calcul borné vers un Web Worker. Conservez la réponse immédiate sur le thread principal, mais reportez l'analytics et autres travaux non essentiels. Traitez chaque tag tiers comme une dépendance avec un propriétaire. Retestez sur un CPU mobile contraint et prévoyez un rollback pour les parcours critiques.

GUIDE VISUEL

Voyez le travail comme un système.

Utilisez cette carte pour relier les décisions de l'article avant d'agir sur des tactiques isolées.

SIUAccélérer
01Profilez un parcours client avant de changer le code
02Lisez la trace comme une file de travail
03Envoyez moins de code au moment où ça compte
04Découpez le travail pour que le navigateur puisse répondre
01

Profilez un parcours client avant de changer le code

Choisissez un itinéraire et une interaction importants, par exemple ouvrir la navigation, filtrer des résultats ou soumettre un formulaire. Enregistrez-le dans le panneau Performance de Chrome DevTools depuis un état de navigateur propre. Répétez l'action et capturez un run avec CPU throttling ainsi qu'un run sur machine de développement ; les traces desktop peuvent masquer du travail perturbateur sur un téléphone moins puissant.

Utilisez la trace pour tester une hypothèse ciblée, pas pour blâmer un composant à partir d'un rapport de bundle. Dans le flame chart principal (Main flame chart), les barres plus larges prennent plus de temps et les barres empilées montrent la pile d'appels. Un triangle rouge sur une Task identifie une long task potentielle ; sélectionnez-la et suivez le lien vers le code initiateur. Sauvegardez les traces avant-après pour des changements significatifs.

Capturez l'instant

Enregistrez juste avant l'action et arrêtez après le résultat visible.

Utilisez un cas répétable

Conservez route, état du compte et séquence d'action constants.

Nommez un propriétaire

Attribuez chaque coût majeur à l'équipe ou au fournisseur capable de le modifier.

02

Lisez la trace comme une file de travail

Une tâche longue est un seuil d’investigation, pas un diagnostic complet. La spécification W3C Long Tasks recense les tâches qui durent 50 millisecondes ou plus. Examinez, sous une tâche, l’évaluation de JavaScript, un gestionnaire d’événements, le recalcul des styles, la mise en page ou le rendu. La pile d’appels indique par où commencer ; le minutage montre si le problème vient du code, du rendu ou d’un cadre tiers.

Priorisez les coûts qui se répètent pendant une interaction à valeur. Un handler court peut néanmoins paraître lent s'il déclenche un layout ou attend derrière un travail antérieur. La trace est une mesure de laboratoire : confirmez la correction sur des appareils représentatifs et, lorsque disponible, avec une télémétrie terrain soucieuse de la vie privée.

Séparez les moments

Le parsing au démarrage exige un remède différent d'un handler post-tap.

Inspectez le rendu

Repérez les motifs répétés d'écriture de style et de lecture de layout avant de refactorer.

Conservez une baseline

Joignez la trace, le scénario et les principaux coûts à l'élément de travail.

03

Envoyez moins de code au moment où ça compte

Inventoriez les scripts par route et par usage. Supprimez les packages inutilisés, les duplicatas, les expériences obsolètes et le code pour des fonctionnalités terminées. Ensuite, découpez les fonctionnalités spécifiques à une route ou rarement utilisées pour qu'elles se chargent quand elles sont nécessaires plutôt que sur le chemin initial. Le chargement dynamique peut réduire le travail de démarrage, mais il peut créer un délai visible lorsque l'utilisateur a besoin de la fonctionnalité immédiatement.

Demandez-vous si un composant a réellement besoin d’un framework complet côté client, si un utilitaire fait doublon avec une capacité existante, ou si du HTML statique complété par une petite amélioration suffit. Testez l’état de repli d’un module chargé ultérieurement. La page doit pouvoir reporter proprement une fonction facultative plutôt que d’afficher une commande inactive.

Construisez un budget par route

Documentez quels scripts sont autorisés sur une route et pourquoi.

Chargez sur intention

Envisagez ceci pour éditeurs optionnels, cartes, players ou vues de reporting.

Protégez les chemins critiques

Testez l'authentification, l'accessibilité, le paiement et la complétion de formulaire ; demandez une revue qualifiée quand des contrôles sont affectés.

04

Découpez le travail pour que le navigateur puisse répondre

Donner des noms à de plus petites fonctions ne crée pas de tâches navigateur séparées quand elles s'exécutent de façon synchrone. Pour une boucle longue, traitez par lots, mettez à jour l'état visible immédiatement, puis cédez la main avant de continuer. Cela permet au navigateur de traiter les entrées et le rendu entre les lots.

Là où c'est pris en charge, scheduler.yield() cède le thread principal et reprend le travail plus tard ; détectez la fonctionnalité et prévoyez un fallback pour les navigateurs non supportés. Ne cédez pas après chaque minuscule opération : cela a un coût et peut augmenter le temps d'achèvement. Choisissez les frontières à partir des mesures, préservez l'annulation et empêchez que des résultats obsolètes remplacent un état plus récent.

Priorisez l'UI

Affichez l'acceptation ou la progression avant un travail de suivi non visible.

Traitez par lots selon le temps écoulé

Cédez avant que le travail mesuré ne devienne long, plutôt qu'une fois par élément.

Évitez les raccourcis obsolètes

Les recommandations web.dev actuelles ne préconisent pas une nouvelle stratégie basée sur isInputPending().

05

Déplacez le calcul, pas l'interface, vers un worker

Un Web Worker exécute un script sur un thread d'arrière-plan séparé du thread d'exécution principal. Il convient pour du parsing coûteux, la transformation de données, l'indexation de recherche et d'autres calculs qui n'ont pas besoin d'accès direct à l'interface. Envoyez une entrée définie, renvoyez un résultat défini, et conservez le rendu et les changements d'état visibles sur le thread principal.

Les workers ne conviennent pas à tous les cas. Ils ne peuvent pas manipuler directement le DOM ni utiliser Window, et la communication par messages copie généralement les données. La création d’un worker, le transfert des données et la coordination des erreurs peuvent coûter plus qu’un petit calcul. Mesurez l’interaction complète, arrêtez les workers devenus inutiles et prévoyez une solution de repli si leur traitement échoue.

Choisissez un travail isolé

Commencez par un calcul dont l'entrée et la sortie peuvent être sérialisées et testées.

Versionnez les messages

Ignorez les résultats générés pour un ancien filtre, une route ou une action.

Préservez l'accessibilité

Communiquez une progression significative via l'interface normale.

06

Gérez le JavaScript tiers comme une dépendance de production

Analytics, publicité, expériences, embeds sociaux, players vidéo et widgets d'assistance peuvent ajouter des requêtes, de l'évaluation JavaScript, des iframes et des dépendances. Un script fournisseur peut être nécessaire, mais il échappe au contrôle direct de l'équipe applicative et peut affecter performance, confidentialité, sécurité et continuité. Inventoriez son objectif, les routes, la condition de chargement, l'approbateur, l'exigence de consentement et le propriétaire de la suppression.

Lorsque les conditions et les contrats le permettent, comparez une page représentative avec et sans une origine tierce. Les outils de performance peuvent révéler une évaluation coûteuse, des charges utiles importantes et l’attribution de tâches longues. Ne conservez une intégration légère ou différée que si sa valeur documentée justifie son coût mesuré. Vérifiez que le contenu essentiel et la transaction principale fonctionnent lorsqu’une dépendance facultative est lente ou indisponible.

Limitez le rayon d'impact

Chargez un tag seulement sur les routes et conditions qui en ont besoin.

Revoyez le contrôle des changements

Incluez les changements du tag-manager dans la revue performance, confidentialité, sécurité et rollback.

Conservez un interrupteur de suppression

Documentez et testez comment désactiver une intégration non critique.

07

Faites de la réactivité un garde-fou de release

Transformez la trace gagnante en une petite vérification de régression pour le parcours important. Définissez les interactions couvertes, la contrainte d'appareil ou de CPU, la réponse attendue et le réviseur. Associez-la à une revue d'inventaire des bundles et des tiers pour qu'un nouveau package ou tag ne puisse pas réintroduire silencieusement du travail sur le thread principal.

Status Is UP utilise cette preuve pour l'optimisation proactive et la remédiation sûre, pas pour remplacer la supervision de disponibilité en production. Avant un changement à haut risque, préparez le rollback et vérifiez le parcours critique après la mise en production. Les résultats varient selon l'appareil, le réseau, le navigateur, le contenu et l'état du compte ; considérez les seuils comme des garde-fous, pas des garanties.

Contrôlez les changements importants

Exigez des traces avant-après pour la navigation partagée, le checkout, la recherche ou les gros bundles.

Exercez le rollback

Connaissez le feature flag, le réglage du tag ou la version de déploiement qui restaure le comportement connu comme bon.

Revenez-y régulièrement

Re-profilez après des releases majeures, des changements de fournisseurs ou des évolutions de la répartition des appareils.

ACTION / VÉRIFIER

Votre guide pratique des actions à mener.

  1. 01

    Sélectionnez une interaction critique

    Nommez la route, l'action, la réponse attendue et l'impact client.

    VÉRIFIER: Une note de test enregistre la route, l'état du compte, l'action, le navigateur et le réglage d'appareil ou de CPU.
  2. 02

    Enregistrez une baseline

    Enregistrez l'interaction dans DevTools Performance depuis un état propre.

    VÉRIFIER: L'équipe peut réexaminer une trace avec le Main flame chart.
  3. 03

    Trouvez le travail bloquant

    Inspectez les long tasks, les piles d'appels, le rendu et l'activité tierce.

    VÉRIFIER: Chaque coût majeur a une durée, une source ou origine, une route et un propriétaire.
  4. 04

    Supprimez les scripts inutiles

    Supprimez packages inutilisés, expériences arrêtées, duplicatas et code de route non nécessaire.

    VÉRIFIER: Le build et le parcours critique fonctionnent après la suppression.
  5. 05

    Différez les fonctionnalités optionnelles

    Chargez la capacité optionnelle plus tard seulement si son état différé reste utilisable.

    VÉRIFIER: Un test sur une page fraîche couvre le chargement, l'échec ou le fallback.
  6. 06

    Scindez les long tasks

    Traitez par lots et cédez après la réponse d'interface immédiate.

    VÉRIFIER: Une nouvelle trace élimine la long task comparable du chemin d'interaction et préserve les résultats corrects.
  7. 07

    Évaluez un worker

    Déplacez uniquement le calcul borné avec des messages définis.

    VÉRIFIER: Testez le timing de bout en bout, les erreurs, les résultats obsolètes et le nettoyage.
  8. 08

    Auditez les tiers

    Enregistrez l'objectif, le propriétaire, la condition, le consentement, le coût et la procédure de désactivation.

    VÉRIFIER: Chaque tag de route critique a une décision garder, limiter, différer ou supprimer.
  9. 09

    Testez en conditions contraintes

    Répétez avec CPU throttling et navigateurs ou appareils représentatifs quand c'est faisable.

    VÉRIFIER: La comparaison utilise le même scénario et note les différences significatives.
  10. 10

    Release avec rollback

    Joignez la trace, la vérification d'acceptation et l'instruction de retour à la release.

    VÉRIFIER: Un propriétaire nommé peut restaurer le comportement connu comme bon sans recherche non documentée.
SUJETS DE DISCUSSION

Comparez les compromis, pas les données privées.

Utilisez ces propositions avec votre équipe ou la communauté de propriétaires de sites. Partagez des méthodes et des enseignements, mais ne collez jamais d'identifiants, d'enregistrements clients ou de détails d'infrastructure non publics.

  1. 01

    Quelle interaction paraissait acceptable dans un rapport de chargement mais s'est révélée lente lorsque vous avez profilé un vrai tap ou clic ?

  2. 02

    Comment décidez-vous si une fonctionnalité tierce justifie son coût mesuré sur le thread principal ?

  3. 03

    Quel mécanisme de rollback permet de mieux inverser une régression de performance sans perturber un parcours critique ?

RESSOURCES POPULAIRES / DE RÉFÉRENCE

Consultez le matériel source.

web.devOptimize long tasks ↗

Explique les long tasks, le yielding, scheduler.yield(), les fallbacks et le coût du yield.

Examiné le 2026-09-27
Chrome for DevelopersAnalyze runtime performance ↗

Montre l'enregistrement, l'analyse du flame chart, l'identification des long tasks et l'investigation de la source.

Examiné le 2026-09-27
MDN Web DocsWeb Workers API ↗

Définit les workers, la communication par message et la limite d'accès direct au DOM.

Examiné le 2026-09-27
web.devLoad Third-Party JavaScript ↗

Fournit des conseils d'audit et de mesure pour les scripts tiers.

Examiné le 2026-09-27
W3CLong Tasks API ↗

Définit les long tasks, le seuil et l'attribution.

Examiné le 2026-09-27

Politique des sources. Cet article utilise la documentation officielle des navigateurs, des standards et de la plate-forme web consultée par l'équipe éditoriale. Il distingue la mesure des garanties et omet les affirmations non supportées.

CLARIFICATIONS RAPIDES

Questions fréquentes.

Qu'est-ce qui compte comme une longue tâche JavaScript ?

La W3C Long Tasks specification utilise 50 millisecondes ou plus comme seuil de reporting. C'est un signal pour investiguer, pas la preuve que des tâches plus courtes sont inoffensives. Confirmez la cause dans une trace.

Le code splitting améliorera-t-il toujours les performances JavaScript ?

Non. Le découpage peut réduire le travail de démarrage mais ajouter un délai au premier usage. Utilisez-le pour le code spécifique à une route ou optionnel, puis testez la fonctionnalité sous des conditions contraintes.

Toute fonction coûteuse doit-elle s'exécuter dans un Web Worker ?

Non. Les workers conviennent aux calculs CPU-intensifs isolés avec des messages définis. Ils ne peuvent pas modifier directement le DOM, le transfert de données prend du temps, et les petites tâches peuvent finir plus vite sur le thread principal.

Status Is UP Editorial Team · Rédacteurs Uptime Enablement

Examiné par Relecteur ou relectrice senior en performances web. Publié 2026-09-27; mis à jour 2026-09-30.