Layout shift causato dalle transizioni CSS

Scopri come trovare e rimuovere le transizioni CSS che creano layout shift

Arjen Karel
Aggiornato il · 6 min di lettura
Condividi

Perché le transizioni CSS causano layout shift

I Cumulative Layout Shift causati dalle transizioni CSS si verificano di solito all'inizio, durante la fase di caricamento della pagina. Una transizione su width o height anima la variazione di dimensione quando un foglio di stile o uno script arrivato in ritardo modifica lo stile, e il contenuto sottostante si sposta. Questi shift non si verificano a ogni visualizzazione della pagina. Questo li rende difficili da debuggare.

Il problema di transition: all

La causa che trovo più spesso è transition: all. È ovunque. Secondo il capitolo CSS del Web Almanac 2022, la usa il 53% delle pagine, più di qualsiasi altra proprietà di transizione. Così si animano anche width e height, spostando il contenuto circostante.

Una transizione CSS è composta da quattro parti: la proprietà, la durata, la timing function e un ritardo. Nella sintassi abbreviata:

/* property | duration | timing-function | delay */
transition: margin-right 4s ease-in-out 1s;

Il problema inizia con transition: all .3s ease su un elemento in cui lo sviluppatore voleva solo sfumare un colore all'hover.

Una transizione non parte mai sul primo stile calcolato dal browser per un elemento. Si attiva solo quando quello stile cambia in seguito, e durante il caricamento della pagina succede di continuo: un foglio di stile che arriva in ritardo, o uno script che aggiunge una classe al menu di navigazione. Con transition: all il browser anima anche la variazione di dimensione. Così il menu above the fold si espande per 300 millisecondi fino a posizionarsi, spingendo verso il basso tutto ciò che sta sotto. Un layout shift che si verifica solo durante il caricamento. Buona fortuna a riprodurlo.

Quali proprietà CSS causano layout shift?

Non tutte le transizioni CSS causano layout shift. Solo una proprietà che modifica le dimensioni o la posizione di un elemento costringe il browser a ricalcolare il layout, e solo il layout sposta il contenuto circostante. Secondo le ricerche di Google, le pagine che animano proprietà CSS che innescano il layout hanno il 15% di probabilità in meno di superare il CLS. Con margin e border-width va anche peggio: le pagine che le animano hanno un CLS scarso con una frequenza quasi doppia rispetto al normale.

Ognuna di queste proprietà innesca il ricalcolo del layout; applicare una transizione a una qualsiasi di esse può quindi spostare l'elemento stesso o il contenuto circostante: width, height, margin, padding, top, left, right, bottom, border-width, font-size.

Sicure per il CLS: transform e opacity possono girare sul compositor. Filter e clip-path costano al massimo un repaint. Nessuna delle due coppie innesca il layout.

Solo paint, quindi altrettanto sicure per il CLS: background-color, color, box-shadow, outline.

Transform e opacity sono le due che contano davvero. Una transform non modifica la posizione dell'elemento nel layout, quindi il CLS non la conteggia mai come layout shift. Devi spostare un elemento? Usa transform: translate() al posto di top e left. Per ingrandirlo o rimpicciolirlo, usa transform: scale() invece di width e height.

Nemmeno l'hover è una scusa. Il CLS ignora gli shift nei 500 ms successivi a un click, un tap o alla pressione di un tasto, ma il movimento del mouse su un elemento non rientra in questi input: una transizione in hover su width viene quindi conteggiata per intero.

Il video qui sotto mostra una transizione che sposta il layout durante la fase di caricamento. Mi capita di vederlo di continuo. E individuarlo richiede un po' di indagine.

Trova e correggi le transizioni CSS

Per trovare tutti i layout shift causati da una transizione CSS, elenca prima tutte le transizioni presenti sulla pagina e controlla quali animano proprietà che incidono sul layout. Poi disattivale o modificale, e misura se il CLS scompare.

Consiglio sui Core Web Vitals: questi shift avvengono all'inizio del caricamento della pagina e non a ogni visita. Emula un dispositivo mobile, imposta il throttling della rete e disabilita la cache. Con un caricamento lento, il browser esegue il paint della pagina prima che arrivino lo stylesheet o lo script in ritardo, quindi lo shift si manifesta molto più spesso.

Step 1: trova le transizioni CSS

Puoi cercare le transizioni CSS a mano: apri ogni foglio di stile e cerca la parola 'transition'. Dieci minuti, forse. Più rapido: incolla questo snippet nella console e premi Invio.

(() => {

  let nodeTable = [];
  let nodeArray = [];

  // Get the name of the node
  function getName(node) {
    const name = node.nodeName;
    return node.nodeType === 1
      ? name.toLowerCase()
      : name.toUpperCase().replace(/^#/, '');
  }

  // Get the selector
  const getSelector = (node) => {
    let sel = '';

    try {
      while (node && node.nodeType !== 9) {
        const el = node;
        const part = el.id
          ? '#' + el.id
          : getName(el) +
          (el.classList &&
            el.classList.value &&
            el.classList.value.trim() &&
            el.classList.value.trim().length
            ? '.' + el.classList.value.trim().replace(/\s+/g, '.')
            : '');
        if (sel.length + part.length > (100) - 1) return sel || part;
        sel = sel ? part + '>' + sel : part;
        if (el.id) break;
        node = el.parentNode;
      }
    } catch (err) {
      // Do nothing...
    }
    return sel;
  };

  const getNodesWithTransition = (node) => {

    // Get the computed style
    let cs = window.getComputedStyle(node);
    let tp = cs['transition-property'];
    let td = cs['transition-duration'];

    // If there is a transition, add it to the table
    if (tp !== '' && tp !== 'none' && td != '0s') {
      nodeTable.push({ selector: getSelector(node), transition: cs['transition'] });
      nodeArray.push(node);
    }

    // Recursively call this function for each child node
    for (let i = 0; i < node.children.length; i++) {
      getNodesWithTransition(node.children[i]);
    }
  }

  // find all transitions
  getNodesWithTransition(document.body);

  // Display the results in the console
  console.log('%cReadable table of selectors and their transitions', 'color: red; font-weight: bold;');
  console.table(nodeTable);

  console.log('%cNodeList for you to inspect (harder to read but more info)', 'color: red; font-weight: bold;');
  console.log(nodeArray);


  // styles to temporarity override the transitions
  let selectors = nodeTable.map((item) => item.selector).join(', ');

  console.log('%cSpecific CSS to disable all transitions on this page', 'color: red; font-weight: bold;');
  console.log(`<style>${selectors}{transition-property: none !important;}</style>`);

  console.log('%cGlobal CSS to disable all transitions on this page (not suggested on production)', 'color: red; font-weight: bold;');
  console.log(`<style>*{transition-property: none !important;}</style>`);

})()

Genera una tabella con tutte le transizioni della pagina e il rispettivo elemento.

Ora esamina la colonna delle transizioni. Parti da ogni riga con all: copre qualsiasi proprietà animabile, comprese width e height. Poi cerca le righe che indicano direttamente width o height. Anche margin e padding spostano il contenuto, e lo stesso vale per top e left.

Step 2: modifica le transizioni CSS

Lo snippet genera anche il CSS per disattivare queste transizioni. Per un test rapido, scegli la via più semplice e disabilita tutte le transizioni con una sola riga:

<style>*{transition-property: none !important;}</style>

Su un sito in produzione serve più precisione. Rimuovi solo le proprietà di transizione che non servono, selettore per selettore. Per esempio, modifica #button{transition: all .2s} in #button{transition: background-color .2s}.

Step 3: misura la variazione del layout shift

Ultimo passaggio: misura. La mia estensione Chrome Core Web Vitals Visualizer mostra gli shift direttamente sullo schermo, mentre un tool RUM come CoreDash mostra se sono scomparsi anche per i visitatori reali. Su CoreDash puoi scomporre il CLS in base all'elemento che si è spostato. Dopo la modifica, quel menu o banner dovrebbe sparire dall'elenco e il p75 su mobile dovrebbe seguirlo a ruota.

Best practice per le transizioni

  1. Indica la proprietà esatta. Scrivi transition: background-color .2s ease al posto di transition: all: una proprietà che non intendevi animare non potrà spostare nulla.
  2. Anima transform e opacity. Il browser può gestirle entrambe sul compositor e nessuna delle due innesca il layout. Usa transform: translate() per spostare un elemento e transform: scale() per ridimensionarlo. Opacity serve per le dissolvenze. È ciò che raccomanda anche Google.
  3. Assegna width e height esplicite, o un aspect ratio, sia prima che dopo la transizione dell'elemento, in modo che il contenuto circostante non si sposti. Ne parlo più a fondo nell'articolo su come risolvere i layout shift causati da immagini con ridimensionamento automatico.
  4. Usa will-change con parsimonia. Indica al browser di prepararsi a un'animazione promuovendo l'elemento su un proprio layer del compositor. Ma questo ha un costo. Con will-change: transform, l'elemento riceve un nuovo stacking context e diventa il containing block per i suoi discendenti posizionati, e ogni layer aggiuntivo consuma memoria GPU. Impostalo con JavaScript subito prima che l'animazione inizi e rimuovilo al termine. Non lasciarlo nel foglio di stile in modo permanente.

Moltissimi siti commettono ancora questo errore. Il Web Almanac 2025 rileva animazioni non composite sul 40% delle pagine mobile. Il CLS è il Core Web Vital con la percentuale di superamento più alta: l'81% su mobile. Se il tuo sito rientra nel 19% che non lo supera, le transizioni CSS potrebbero essere la causa che non hai ancora verificato.

About the author

Arjen Karel is a web performance consultant and the creator of CoreDash, a Real User Monitoring platform that tracks Core Web Vitals data across hundreds of sites. He also built the Core Web Vitals Visualizer Chrome extension. He has helped clients achieve passing Core Web Vitals scores on over 925,000 mobile URLs.

Arjen Karel

Ti serve un sito più veloce?

Sono Arjen e da 17 anni sistemo siti lenti. Se hai problemi che non riesci a risolvere da solo, mandami il tuo URL e ne parliamo.

Mandami il tuo URL
Arjen Karel
Arjen Karel, Consulente web performance dal 2009

Perché il fix non funziona?

A volte la CDN serve ancora il vecchio HTML, oppure il fix è finito nel template desktop e il mobile ne usa un altro. Mandami il tuo URL e il problema, e ti rispondo con qualche orario. Prima analizzo i tuoi field data, poi dedichiamo un'ora al tuo sito, ed entro un giorno hai le mie note per iscritto. 350 € IVA esclusa.

Mandami il tuo URL

Non hai uno sviluppatore per il fix? Faccio io il lavoro, su una copia del tuo sito.

Arjen KarelCore Web Vitals in rosso su mobile?Mandami il tuo URL