Layout shift causado por transições CSS
Saiba como encontrar e remover transições CSS que criam layout shifts
Partilhar
Porque é que as transições CSS causam layout shifts
Os Cumulative Layout Shifts causados por transições CSS acontecem normalmente cedo, durante a fase de carregamento da página. Uma transição em width ou height anima a alteração de tamanho quando uma stylesheet ou um script tardio altera o estilo, e o conteúdo abaixo move-se com ela. Estes shifts não acontecem em todas as visualizações de página. Isso dificulta o debug.
O problema do transition: all
A causa que encontro com mais frequência é o transition: all. Está em todo o lado. De acordo com o capítulo de CSS do Web Almanac de 2022, 53% das páginas usam-no — mais do que qualquer outra propriedade de transição. Assim, o width e o height também são animados e movem o conteúdo em redor do elemento.
Uma transição CSS tem quatro partes: a propriedade, a duração, a timing function e o delay. Em shorthand:
/* property | duration | timing-function | delay */
transition: margin-right 4s ease-in-out 1s; O problema começa com transition: all .3s ease num elemento onde o developer só queria fazer fade da cor no hover.
Uma transição nunca é executada no primeiro estilo que o browser calcula para um elemento. Só corre quando esse estilo muda mais tarde — e durante o carregamento da página isso acontece com frequência: uma stylesheet que chega tarde ou um script que adiciona uma classe ao menu de navegação. Com transition: all, o browser também anima a alteração de tamanho. O menu above the fold expande-se ao longo de 300 milissegundos e empurra tudo o que está por baixo. Um layout shift que só acontece durante o carregamento. Boa sorte a reproduzi-lo.
Que propriedades CSS causam layout shift?
Nem todas as transições CSS causam layout shifts. Apenas as propriedades que alteram o tamanho ou a posição de um elemento forçam o browser a executar o layout novamente — e só o layout move o conteúdo em redor. Segundo estudos da Google, as páginas que animam propriedades CSS que desencadeiam layout têm menos 15% de probabilidade de passar no CLS. As propriedades margin e border-width são ainda piores. As páginas que as animam apresentam um CLS fraco quase com o dobro da frequência normal.
Cada uma destas propriedades desencadeia o recálculo do layout. Criar uma transição em qualquer uma delas pode deslocar o próprio elemento ou o conteúdo circundante: width, height, margin, padding, top, left, right, bottom, border-width, font-size.
Seguras para o CLS: transform e opacity podem correr no compositor. Filter e clip-path custam, no máximo, um repaint. Nenhum dos pares desencadeia layout.
Apenas paint, logo também seguras para o CLS: background-color, color, box-shadow, outline.
Transform e opacity são as duas que interessam. Um transform não altera a posição do elemento no layout, pelo que o CLS nunca o contabiliza como um layout shift. Precisa de mover um elemento? Use transform: translate() em vez de top e left. Para o fazer parecer maior ou menor, use transform: scale() em vez de width e height.
O hover também não serve de desculpa. O CLS ignora shifts nos 500 ms após um clique, um toque ou o premir de uma tecla. No entanto, passar o rato sobre um elemento não conta como essa interação — por isso, uma transição de hover em width conta por inteiro.
O vídeo abaixo mostra uma transição a deslocar o layout durante a fase de carregamento. Vejo isto constantemente. Encontrar o problema exige investigação.
Encontrar e corrigir transições CSS
Para encontrar todos os layout shifts provocados por transições CSS, liste todas as transições da página e verifique quais animam propriedades que afetam o layout. Depois, desative ou altere essas propriedades e meça se o CLS desaparece.
Dica de Core Web Vitals: estes shifts acontecem no início do carregamento da página e não em todas as visitas. Emule um telemóvel, limite a velocidade da rede (throttling) e desative a cache. Num carregamento lento, o browser faz o paint da página antes da chegada da stylesheet ou do script tardio, pelo que o shift surge com muito mais frequência.
Passo 1: encontrar transições CSS
Pode procurar as transições CSS manualmente: abra cada stylesheet e pesquise pela palavra 'transition'. Talvez demore dez minutos. Mais rápido: cole este snippet na consola e prima Enter.
(() => {
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>`);
})() O snippet imprime uma tabela com todas as transições da página e o respetivo elemento onde estão aplicadas.

Agora analise a coluna das transições. Comece por todas as linhas com all: abrange todas as propriedades que podem ser animadas, incluindo width e height. Depois, procure linhas que indiquem width ou height diretamente. Margin e padding também movem conteúdo, tal como top e left.
Passo 2: modificar transições CSS
O snippet também imprime o CSS para desativar essas transições. Para um teste rápido, opte pela via mais simples e desative todas as transições com uma só linha:
<style>*{transition-property: none !important;}</style>Num site em produção, é preciso mais critério. Remova apenas as propriedades de transição de que não precisa, seletor a seletor. Por exemplo, altere #button{transition: all .2s} para #button{transition: background-color .2s}.
Passo 3: medir a alteração no layout shift

Boas práticas para transições
- Especifique a propriedade exata. Escreva
transition: background-color .2s easeem vez detransition: all, e uma propriedade que não pretendia animar não conseguirá deslocar nada. - Anime transform e opacity. O browser pode correr ambas no compositor e nenhuma desencadeia layout. Use
transform: translate()para mover um elemento etransform: scale()para o redimensionar. A opacity cria o efeito de fade. É também isso que a Google recomenda. - Defina um width e height explícitos (ou um aspect ratio) para qualquer elemento sujeito a transições, tanto antes como depois da transição, para que o conteúdo em redor não saia do sítio. Saiba mais em como corrigir layout shifts causados por imagens com dimensionamento automático.
- Use o
will-changecom moderação. Esta propriedade indica ao browser para se preparar para uma animação, promovendo o elemento à sua própria camada no compositor. Isso tem um custo. Comwill-change: transform, o elemento ganha um novo stacking context e passa a ser o containing block para os seus descendentes posicionados. Além disso, cada camada extra consome memória da GPU. Defina-o com JavaScript imediatamente antes de a animação começar e remova-o quando ela terminar. Não o deixe permanentemente na stylesheet.
Muitos sites continuam a cometer este erro. O Web Almanac de 2025 encontra animações não compostas em 40% das páginas mobile. O CLS é o Core Web Vital com a taxa de aprovação mais elevada: 81% em mobile. Se o seu site está nos 19% que não passam, as transições CSS podem ser a causa que ainda não verificou.

Precisa de um site mais rápido?
Sou o Arjen e há 17 anos que corrijo sites lentos. Se tem problemas que não consegue resolver sozinho, envie-me o seu URL e falamos.
Envie-me o seu URL
Porque é que o nosso fix não está a funcionar?
Por vezes a CDN ainda serve o HTML antigo, ou o fix foi feito no template de desktop e o mobile usa outro. Envie-me o seu URL e o problema, e respondo com alguns horários. Primeiro analiso os seus field data, depois dedicamos uma hora ao seu site, e no prazo de um dia tem as minhas notas por escrito. 350 € sem IVA.
Envie-me o seu URLSem programador para fazer o fix? Faço eu o trabalho, numa cópia do seu site.