CKTIS / CSS
Prestazioni di rendering in DevTools: schermate, FPS, Paint flashing e Layers
Le schermate mostrano l’aspetto, gli FPS indicano la frequenza dei fotogrammi, Paint flashing evidenzia le aree disegnate e Layers mostra i livelli di compositing. Nessuno di questi segnali offre una garanzia di prestazioni basata sul solo CSS.
Versione: Browser DevTools workflow; UI and feature availability vary by browser and version
Sintassi
Performance, Screenshots, FPS, Paint flashing and Layers are DevTools diagnostics, not CSS syntax. Their names, availability and interfaces depend on the browser and its version; CSS specifications define the animation and media query used in the example, not the diagnostic tools. The example uses `animation: move-left 2s linear infinite alternate;` inside `@media (prefers-reduced-motion: no-preference)`. Replace `move-left` with `move-transform` in that declaration for the comparison.Una registrazione in Performance fornisce una linea temporale in cui cercare gli eventi di calcolo degli stili, layout e disegno (paint). Se disponibile, Screenshots aggiunge una sequenza di schermate acquisite in alcuni istanti. Confrontale con gli eventi della traccia: non registrano ogni fotogramma e non misurano il costo del rendering.
Gli FPS sono i fotogrammi al secondo. Controlla anche i tempi dei singoli fotogrammi: una buona media può nascondere scatti occasionali. A 60 Hz passano circa 16,7 ms tra due aggiornamenti dello schermo: non è un limite di tempo universale. Paint flashing evidenzia le aree che vengono disegnate o ridisegnate mentre osservi, ma non misura la durata del lavoro. Anche senza lampeggi, il compositore può combinare contenuti già disegnati.
Layers mostra i livelli usati dal compositore, non i livelli della cascata CSS (@layer) né i contesti di impilamento. Un transform diverso da none crea un contesto di impilamento per un normale box CSS, ma non garantisce un livello di compositing separato. will-change è un suggerimento di ottimizzazione, non un comando per creare un livello; livelli aggiuntivi possono consumare memoria.
Confronta lo stesso movimento con left e transform. Modificare left può richiedere layout e disegno, mentre animare transform può richiedere solo il compositing. Sono ipotesi da verificare, non garanzie del CSS. Ripeti le misurazioni nelle stesse condizioni e verifica i risultati sui dispositivi di destinazione. I nomi e la disponibilità degli strumenti variano a seconda del browser e della versione.
Esempi
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Rendering performance comparison</title>
<style>
#square {
position: relative;
left: 0;
width: 48px;
height: 48px;
background: #2563eb;
}
@media (prefers-reduced-motion: no-preference) {
#square {
animation: move-left 2s linear infinite alternate;
}
}
@keyframes move-left {
from { left: 0; }
to { left: 120px; }
}
@keyframes move-transform {
from { transform: translateX(0); }
to { transform: translateX(120px); }
}
</style>
</head>
<body>
<div id="track"><div id="square"></div></div>
<p><output id="observation"></output></p>
<script>
const track = document.querySelector('#track');
const square = document.querySelector('#square');
const observation = document.querySelector('#observation');
const motion = matchMedia('(prefers-reduced-motion: no-preference)');
const variants = ['move-left', 'move-transform'];
const origin = track.getBoundingClientRect();
const { width, height } = square.getBoundingClientRect();
const { animationName, backgroundColor } = getComputedStyle(square);
const close = (a, b) => Math.abs(a - b) < 0.01;
function check(condition, message) {
if (!condition) throw new Error(message);
}
// Sample the actual CSS animation at known times, before profiling it.
function measure(name) {
square.style.animationName = name;
const [animation] = square.getAnimations();
check(animation?.animationName === name, `Missing animation: ${name}`);
animation.pause();
const { duration, direction, iterations } = animation.effect.getTiming();
check(duration === 2000 && direction === 'alternate' && iterations === Infinity,
`Unexpected timing: ${name}`);
const offsets = [0, 0.5, 1, 1.5, 2].map(step => {
animation.currentTime = step * duration;
const rect = square.getBoundingClientRect();
check(close(rect.top, origin.top), `Unexpected vertical movement: ${name}`);
return rect.left - origin.left;
});
check(offsets.every((x, i) => close(x, [0, 60, 120, 60, 0][i])),
`Unexpected horizontal movement: ${name}`);
return { distance: Math.round(offsets[2] - offsets[0]), seconds: duration / 1000 };
}
try {
check(width === 48 && height === 48 && backgroundColor === 'rgb(37, 99, 235)',
'Unexpected square size or color');
if (motion.matches) {
check(variants.includes(animationName), 'The media query did not activate a comparison variant');
let measured;
try {
measured = measure(animationName);
measure(variants.find(name => name !== animationName));
} finally {
// Remove the paused test animation and let the stylesheet start a fresh one.
square.style.animationName = 'none';
square.getAnimations();
square.style.removeProperty('animation-name');
}
const { distance, seconds } = measured;
observation.textContent = `When the media query matches, a blue ${width} × ${height} CSS-pixel square moves ${distance} CSS pixels to the right in ${seconds} seconds and back in ${seconds} seconds, repeating in either variant. Otherwise it stays at the starting position. No specific FPS, paint pattern, timing cost or layer configuration is expected across browsers and devices.`;
} else {
const rect = square.getBoundingClientRect();
check(animationName === 'none' && square.getAnimations().length === 0 &&
close(rect.left, origin.left) && close(rect.top, origin.top),
'The square is not static at its starting position');
observation.textContent = `The media query does not match. The blue ${width} × ${height} CSS-pixel square stays at the starting position.`;
}
} catch (error) {
observation.textContent = error.message;
throw error;
}
</script>
</body>
</html>Risultato
When the media query matches, a blue 48 × 48 CSS-pixel square moves 120 CSS pixels to the right in 2 seconds and back in 2 seconds, repeating in either variant. Otherwise it stays at the starting position. No specific FPS, paint pattern, timing cost or layer configuration is expected across browsers and devices.
Cambia soltanto il nome dell’animazione da `move-left` a `move-transform`. Verifica che il quadrato percorra la stessa distanza nello stesso tempo, poi confronta le tracce. Se `prefers-reduced-motion: no-preference` non corrisponde, il quadrato rimane fermo.
Lezioni correlate
- CSS · Lezione 29 · Avanzato · Versione: 2