Aller au contenu

Vérificateur de ressources bloquantes

Réponse courte

Ressources bloquant le rendu : repérez scripts et feuilles de style bloquants et pratiques lentes : async/defer manquants, gestionnaires inline, document.write.

Ce qu’il ne fait pas: Il lit le HTML et signale des schémas ; il ne charge pas la page et ne mesure pas combien de temps chaque ressource bloque le rendu. Le test de vitesse de page donne des temps mesurés.

Gratuit · Sans inscription · Fonctionne dans votre navigateur
100 % dans votre navigateur — votre contenu ne quitte jamais votre appareil.

Ce que ça fait

Vérifie le HTML d'une page en deux parties. Ressources bloquant le rendu : scripts dans `<head>` sans `async` ni `defer`, feuilles de style bloquant le rendu et règles CSS `@import`. Hygiène des scripts : combien de scripts externes et inline la page charge, si les scripts externes utilisent `async` ou `defer`, les gestionnaires d'événements inline tels que `onclick`, les appels `document.write` et si des modules ES sont utilisés.

Pourquoi c'est important

Un navigateur doit télécharger et exécuter chaque script et feuille de style bloquants dans `<head>` avant de pouvoir afficher quoi que ce soit, ce qui retarde le First Contentful Paint et souvent le Largest Contentful Paint. `document.write` aggrave la situation — Chrome peut refuser d'exécuter les scripts qu'il injecte sur les connexions lentes — et les gestionnaires inline entravent une Content-Security-Policy stricte.

Comment ça fonctionne

  1. Saisissez l'URL d'une page ou collez son HTML

  2. Nous analysons le `<head>` et chaque `<script>` de la page

  3. Signalons les scripts et feuilles de style bloquant le rendu, puis vérifions les scripts pour async/defer, les gestionnaires inline et document.write

  4. Renvoyons un résultat pour chaque partie, avec les ressources signalées

Exemple d'entrée et de sortie

ENTRÉE
url: https://rankproof.eu/tools
SORTIE
Ressources bloquant le rendu                 92/100
  Scripts bloquants: 0 · Feuilles de style bloquantes: 1 · Ressources dans le head: 7
  Les scripts du head utilisent async ou defer OK
  Aucune feuille de style bloquant le rendu  WARN
  Pas de @import dans le CSS                 OK
  Ressources bloquant le rendu:
    <link rel="stylesheet" href="DFq8YedA.css">

Hygiène des scripts                          100/100
  Scripts: 13 · Externes: 5 · Inline: 8
  Les scripts externes utilisent async ou defer OK
  Aucun gestionnaire d'événements inline     OK
  Pas de document.write                      OK
  Utilise les ES modules                     OK

Domaines en bon état : 1 sur 2 · 96/100

Comment lire le résultat

Deux parties (Domaines en bon état : 1 sur 2 · 96/100)
Les ressources bloquant le rendu et l'hygiène des scripts ont chacune leur propre score, et le score global est leur moyenne. Dans l'exemple, la partie sur les scripts est propre et la première partie a un avertissement : le résumé compte donc un domaine sur deux.
Scripts bloquants (0)
Les scripts dans <head> avec un src et sans async, defer ni type="module". Le navigateur arrête de construire la page pendant que chacun se télécharge et s'exécute, et chacun coûte 15 points à la partie. Les scripts inline et ceux de <body> ne sont pas comptés ici.
Feuilles de style bloquantes (1)
Chaque <link rel="stylesheet"> dans <head> qui n'est ni media="print" ni désactivé. Le navigateur n'affiche rien tant qu'il n'a pas ces fichiers : une feuille de style principale est donc normale. Une seule feuille donne un avertissement, deux ou plus échouent. Le fichier unique de l'exemple est la feuille de style du site, nommée d'après son contenu. Une feuille de style avec une autre media query est quand même comptée, bien que les navigateurs n'attendent pas celle dont la requête ne correspond pas à l'écran.
Ressources dans le head (7) et @import
Ressources dans le head compte chaque script, feuille de style et bloc <style> dans <head>, bloquant ou non ; cela donne du contexte et n'est pas noté. Un @import dans un bloc <style> coûte 10 points, car le navigateur ne découvre le fichier importé qu'après avoir lu le premier. Les règles @import à l'intérieur des fichiers .css liés ne sont pas vérifiées, car ces fichiers ne sont pas téléchargés.
Hygiène des scripts (13 scripts : 5 externes, 8 inline)
Compte tous les scripts de la page, dans <head> et <body>. Inline compte chaque bloc <script> non vide, y compris les données structurées JSON-LD, qui ne s'exécutent jamais : un nombre élevé n'est donc pas un problème en soi. Les scripts externes sans async, defer ni type="module" coûtent 8 points chacun, les gestionnaires inline comme onclick 4 chacun, et tout appel à document.write 15.
Utilise les ES modules
Réussi quand au moins un script a type="module". Sans cela, c'est un avertissement et non un échec : c'est une invitation à adopter la manière moderne de charger du code, puisque les modules sont différés par défaut.

Qui l'utilise

  • Ingénieur performance

    Avant une saison chargée, passez chaque script bloquant en async ou defer et revérifiez que rien de nouveau ne s'est glissé dans `<head>`.

  • Développeur front-end

    Trouvez l'extrait d'analytics ou de widget qui se charge encore de façon synchrone et basculez-le vers un chargement différé.

  • Spécialiste SEO

    Vérifiez les modèles derrière vos pages les plus lentes et transmettez les ressources signalées à l'équipe de développement.

Problèmes fréquents et comment les corriger

  1. Un script bloquant dans <head>

    Ajoutez defer aux scripts qui ont besoin des éléments de la page ou qui doivent s'exécuter dans l'ordre, et async aux scripts indépendants comme les statistiques. Les scripts avec type="module" sont déjà différés.

    <script src="/js/app.js" defer></script>
    <script src="https://analytics.example/tag.js" async></script>
    <script type="module" src="/js/menu.js"></script>
  2. Plus d'une feuille de style bloquante

    Regroupez votre propre CSS dans un seul fichier au moment du build, donnez media="print" aux styles d'impression, et placez en inline les quelques règles dont le premier écran a besoin pour que la page puisse s'afficher avant l'arrivée du fichier principal.

    <head>
      <style>/* only the rules the first screen needs */ .hero { min-height: 60vh; }</style>
      <link rel="stylesheet" href="/css/site.css">
      <link rel="stylesheet" href="/css/print.css" media="print">
    </head>
  3. @import dans un bloc <style>

    Remplacez-le par un <link rel="stylesheet">, pour que le navigateur puisse trouver et télécharger les deux fichiers en même temps.

    <!-- before -->
    <style>@import url("/css/fonts.css");</style>
    
    <!-- after -->
    <link rel="stylesheet" href="/css/fonts.css">
  4. Gestionnaires d'événements inline

    Déplacez les gestionnaires comme onclick dans un fichier de script et attachez-les avec addEventListener. Une fois qu'il ne reste plus de code inline, une Content-Security-Policy peut retirer 'unsafe-inline'.

    <!-- before -->
    <button onclick="openMenu()">Menu</button>
    
    <!-- after -->
    <button type="button" id="menu-button">Menu</button>
    <script type="module" src="/js/menu.js"></script>
    
    // /js/menu.js
    document.getElementById('menu-button').addEventListener('click', openMenu);
  5. document.write

    Créez plutôt l'élément avec les méthodes du DOM ; les vieux extraits de publicité et de widgets en sont la source habituelle, et la plupart des fournisseurs proposent désormais une version async. La vérification repère le texte document.write( n'importe où dans le HTML : une mention dans un commentaire compte donc aussi.

    const s = document.createElement('script');
    s.src = 'https://widget.example/embed.js';
    s.async = true;
    document.head.append(s);

Questions fréquentes

Comment débloquer une feuille de style ?
Mettez en ligne dans un bloc `<style>` les quelques règles dont le premier écran a besoin, gardez le reste dans une seule feuille de style et donnez `media="print"` aux styles d'impression. L'astuce `onload="this.media='all'"` fonctionne aussi, mais c'est un gestionnaire en ligne : ce contrôle le signale et une Content-Security-Policy stricte le bloque.
Puis-je simplement différer tous mes scripts ?
Pas toujours — les scripts qui doivent s'exécuter avant le premier affichage, les polyfills requis pour la mise en page et les scripts inline ne peuvent pas toujours attendre. Auditez-les selon leur impact.
Qu'est-ce qui ne va pas avec document.write ?
Il force le navigateur à mettre en pause l'analyse, et Chrome peut bloquer les scripts qu'il injecte sur les connexions lentes. Insérez les éléments avec des méthodes du DOM à la place.
Pourquoi signaler les gestionnaires d'événements inline ?
Des gestionnaires tels que `onclick="…"` mélangent le comportement au balisage et nécessitent `unsafe-inline` dans une Content-Security-Policy. Attachez plutôt les écouteurs depuis un fichier de script.
Et les widgets tiers ?
Chargez-les avec `<script async>` ou via un gestionnaire de balises avec un chargement différé. Mieux encore, ne chargez les widgets sous la ligne de flottaison qu'au défilement ou à l'interaction.

Sources

La documentation sur laquelle reposent cet outil et les explications de cette page.