Vai al contenuto

Controllo risorse bloccanti

Risposta breve

Risorse che bloccano il rendering: trova script e fogli di stile bloccanti e abitudini che rallentano le pagine, come async/defer mancanti e document.write.

Cosa non fa: Legge l’HTML e segnala gli schemi; non carica la pagina né misura per quanto ogni risorsa blocca il rendering. Il test di velocità della pagina fornisce tempi misurati.

Gratuito · Senza registrazione · Funziona nel browser
100% nel tuo browser — i contenuti non lasciano mai il tuo dispositivo.

Cosa fa

Controlla l'HTML di una pagina in due parti. Risorse bloccanti per il rendering: script in `<head>` senza `async` o `defer`, fogli di stile che bloccano il rendering e regole CSS `@import`. Igiene degli script: quanti script esterni e inline carica la pagina, se gli script esterni usano `async` o `defer`, gestori di eventi inline come `onclick`, chiamate a `document.write` e se vengono usati moduli ES.

Perché è importante

Un browser deve scaricare ed eseguire ogni script e foglio di stile bloccante nel `<head>` prima di poter disegnare qualsiasi cosa, il che ritarda il First Contentful Paint e spesso il Largest Contentful Paint. `document.write` peggiora la situazione: Chrome può rifiutarsi di eseguire gli script che inietta sulle connessioni lente, e i gestori inline ostacolano una Content-Security-Policy rigorosa.

Come funziona

  1. Inserisci l'URL di una pagina o incolla il suo HTML

  2. Analizziamo il `<head>` e ogni `<script>` della pagina

  3. Segnaliamo gli script e i fogli di stile bloccanti, poi controlliamo gli script per async/defer, gestori inline e document.write

  4. Restituiamo un risultato per ciascuna parte, con le risorse segnalate

Esempio di input e output

INPUT
url: https://rankproof.eu/tools
OUTPUT
Risorse che bloccano il rendering            92/100
  Script bloccanti: 0 · Fogli di stile bloccanti: 1 · Risorse nel head: 7
  Gli script nel head usano async o defer    OK
  Nessun foglio di stile bloccante           WARN
  Nessun @import nel CSS                     OK
  Risorse che bloccano il rendering:
    <link rel="stylesheet" href="DFq8YedA.css">

Igiene degli script                          100/100
  Script: 13 · Esterni: 5 · Inline: 8
  Gli script esterni usano async o defer     OK
  Nessun gestore di eventi inline            OK
  Nessun document.write                      OK
  Utilizza ES modules                        OK

Aree a posto: 1 su 2 · 96/100

Come leggere il risultato

Due parti (aree a posto: 1 su 2 · 96/100)
Le risorse che bloccano il rendering e l'igiene degli script hanno ciascuna il proprio punteggio, e il punteggio complessivo è la loro media. Nell'esempio la parte sugli script è pulita e la prima ha un avviso, quindi il riepilogo conta una su due.
Script bloccanti (0)
Script nel <head> con un src e senza async, defer o type="module". Il browser smette di costruire la pagina mentre ognuno viene scaricato ed eseguito, e ognuno costa alla parte 15 punti. Gli script inline e quelli nel <body> qui non vengono contati.
Fogli di stile bloccanti (1)
Ogni <link rel="stylesheet"> nel <head> che non sia media="print" o disabilitato. Il browser non disegna nulla finché non ha questi file, quindi un solo foglio di stile principale è normale: uno è un avviso, due o più sono un errore. L'unico file dell'esempio è il foglio di stile del sito, con un nome ricavato dal suo contenuto. Un foglio di stile con un'altra media query viene comunque contato, anche se i browser non aspettano quello la cui query non corrisponde allo schermo.
Risorse nel head (7) e @import
Risorse nel head conta ogni script, foglio di stile e blocco <style> nel <head>, bloccante o no; serve da contesto e non entra nel punteggio. Un @import dentro un blocco <style> costa 10 punti, perché il browser trova il file importato solo dopo aver letto il primo. Le regole @import dentro i file .css collegati non vengono controllate, perché quei file non vengono scaricati.
Igiene degli script (Script: 13 · Esterni: 5 · Inline: 8)
Conta ogni script della pagina, nel <head> e nel <body>. Inline conta ogni blocco <script> non vuoto, compresi i dati strutturati JSON-LD, che non vengono mai eseguiti, quindi un numero alto non è di per sé un problema. Gli script esterni senza async, defer o type="module" costano 8 punti ciascuno, i gestori inline come onclick 4 ciascuno, e qualsiasi chiamata a document.write 15.
Utilizza ES modules
Superato quando almeno uno script ha type="module". Senza, è un avviso e non un errore: è un suggerimento verso il modo moderno di caricare il codice, perché i moduli sono differiti per impostazione predefinita.

Chi lo usa

  • Ingegnere delle performance

    Prima di un periodo intenso, sposta ogni script bloccante su async o defer e ricontrolla che nulla di nuovo si sia infiltrato nel `<head>`.

  • Sviluppatore frontend

    Trova lo snippet di analytics o widget che si carica ancora in modo sincrono e passalo a un caricamento differito.

  • Specialista SEO

    Controlla i template dietro alle tue pagine più lente e passa le risorse segnalate al team di sviluppo.

Problemi comuni e come risolverli

  1. Uno script bloccante nel <head>

    Aggiungi defer agli script che hanno bisogno degli elementi della pagina o devono girare in ordine, e async a quelli indipendenti, come l'analisi statistica. Gli script con type="module" sono già differiti.

    <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. Più di un foglio di stile bloccante

    Unisci il tuo CSS in un solo file in fase di build, dai agli stili di stampa media="print" e inserisci inline le poche regole necessarie alla prima schermata, così la pagina può essere disegnata prima che arrivi il file principale.

    <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 in un blocco <style>

    Sostituiscilo con un <link rel="stylesheet">, così il browser può trovare e scaricare i due file nello stesso momento.

    <!-- before -->
    <style>@import url("/css/fonts.css");</style>
    
    <!-- after -->
    <link rel="stylesheet" href="/css/fonts.css">
  4. Gestori di eventi inline

    Sposta gestori come onclick in un file di script e collegali con addEventListener. Quando non resta più codice inline, una Content-Security-Policy può eliminare '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

    Crea invece l'elemento con i metodi del DOM; la fonte abituale sono vecchi snippet di pubblicità e widget, e oggi la maggior parte dei provider offre una versione async. Il controllo cerca il testo document.write( ovunque nell'HTML, quindi conta anche una menzione in un commento.

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

Domande frequenti

Come sblocco un foglio di stile?
Inserisci inline in un blocco `<style>` le poche regole che servono alla prima schermata, tieni il resto in un solo foglio di stile e assegna `media="print"` agli stili di stampa. Il trucco `onload="this.media='all'"` funziona anch'esso, ma è un gestore inline: questo controllo lo segnala e una Content-Security-Policy rigorosa lo blocca.
Posso semplicemente differire tutti i miei script?
Non sempre: gli script che devono essere eseguiti prima del primo rendering, i polyfill necessari per il layout e gli script inline non possono sempre aspettare. Valutali in base all'impatto.
Cosa c'è di sbagliato in document.write?
Costringe il browser a mettere in pausa l'analisi, e Chrome può bloccare gli script che inietta sulle connessioni lente. Inserisci invece gli elementi con i metodi DOM.
Perché segnalare i gestori di eventi inline?
Gestori come `onclick="…"` mescolano il comportamento nel markup e richiedono `unsafe-inline` in una Content-Security-Policy. Collega invece i listener da un file di script.
E i widget di terze parti?
Caricali con `<script async>` o tramite un tag manager con caricamento differito. Meglio ancora, carica i widget sotto la piega solo allo scroll o all'interazione.

Fonti

La documentazione su cui si basano questo strumento e le spiegazioni di questa pagina.