KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / CSS

Renderprestaties in DevTools: screenshots, FPS, Paint flashing en Layers

Screenshots tonen het uiterlijk, FPS geeft de beeldfrequentie aan, Paint flashing markeert getekende gebieden en Layers toont compositielagen. Geen van deze signalen biedt een prestatiegarantie op basis van alleen CSS.

Versie: Browser DevTools workflow; UI and feature availability vary by browser and version

Syntax

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.

Een Performance-opname geeft een tijdlijn waarop je gebeurtenissen voor stijlberekening, layout en tekenen (paint) kunt opzoeken. Screenshots voegt, als de optie beschikbaar is, een reeks momentopnamen van de pagina toe. Leg ze naast de gebeurtenissen op de tijdlijn: ze tonen niet elk frame en meten niet hoeveel werk het renderen kost.

FPS staat voor frames per seconde. Bekijk ook de tijden van afzonderlijke frames: een goed gemiddelde kan incidenteel haperen verbergen. Bij 60 Hz zit er ongeveer 16,7 ms tussen schermverversingen; dat is geen universeel tijdsbudget. Paint flashing laat oplichten welke gebieden worden getekend of opnieuw getekend, maar meet niet hoelang dat duurt. Zonder oplichtende gebieden kan de compositor nog steeds eerder getekende inhoud samenvoegen.

Layers toont lagen die de compositor gebruikt, niet de CSS-cascadelagen (@layer) of stapelcontexten. Een transform met een andere waarde dan none maakt voor een gewone CSS-box een stapelcontext, maar garandeert geen aparte compositielaag. will-change is een optimalisatiehint, geen opdracht om een laag te maken; extra lagen kunnen geheugen kosten.

Vergelijk dezelfde beweging met left en transform. Een wijziging van left kan layout en paint vereisen, terwijl een transform-animatie mogelijk alleen compositing nodig heeft. Beschouw dit als hypotheses die je moet toetsen, niet als CSS-garanties. Herhaal de metingen onder gelijke omstandigheden en controleer de resultaten op de beoogde apparaten. Namen en beschikbaarheid van hulpmiddelen verschillen per browser en versie.

Voorbeelden

<!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>

Resultaat

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.

Verander alleen de animatienaam van `move-left` in `move-transform`. Controleer of het vierkant in dezelfde tijd dezelfde afstand aflegt en vergelijk daarna de opnamen. Als `prefers-reduced-motion: no-preference` niet overeenkomt, blijft het vierkant stilstaan.

Gerelateerde lessen

  • CSS · Les 29 · Gevorderd · Versie: 2

Bronnen