Layout shift causato dalle transizioni CSS
Scopri come trovare e rimuovere le transizioni CSS che creano layout shift
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

Best practice per le transizioni
- Indica la proprietà esatta. Scrivi
transition: background-color .2s easeal posto ditransition: all: una proprietà che non intendevi animare non potrà spostare nulla. - 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 etransform: scale()per ridimensionarlo. Opacity serve per le dissolvenze. È ciò che raccomanda anche Google. - 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.
- Usa
will-changecon parsimonia. Indica al browser di prepararsi a un'animazione promuovendo l'elemento su un proprio layer del compositor. Ma questo ha un costo. Conwill-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.

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
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 URLNon hai uno sviluppatore per il fix? Faccio io il lavoro, su una copia del tuo sito.