WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / CSS

Rendering-Performance in DevTools: Screenshots, FPS, Paint flashing und Layers

Screenshots zeigen das Aussehen, FPS die Bildrate, Paint flashing markiert gezeichnete Bereiche und Layers zeigt die Compositing-Ebenen. Keines dieser Signale liefert eine Performance-Garantie aus dem CSS allein.

Version: 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.

Eine Performance-Aufzeichnung liefert eine Zeitleiste, auf der du nach Ereignissen für Stilberechnung, Layout und Zeichnen (Paint) suchen kannst. Screenshots ergänzen, sofern verfügbar, eine Bildfolge mit Momentaufnahmen der Seite. Ordne sie den Ereignissen auf der Zeitleiste zu: Sie erfassen weder jeden Frame noch die Kosten des Renderings.

FPS steht für Bilder pro Sekunde. Prüfe auch die Zeiten einzelner Frames: Ein guter Durchschnitt kann vereinzelte Ruckler verdecken. Bei 60 Hz liegen ungefähr 16,7 ms zwischen zwei Bildschirmaktualisierungen; das ist kein allgemeines Zeitbudget. Paint flashing hebt Bereiche hervor, die gerade gezeichnet oder neu gezeichnet werden, misst aber nicht die Dauer. Ohne Aufblinken kann trotzdem Rendering-Arbeit anfallen: Der Compositor kann bereits gezeichnete Inhalte zusammenfügen.

Layers zeigt die Ebenen des Compositors, nicht die CSS-Kaskadenebenen (@layer) oder Stapelkontexte. Ein transform ungleich none erzeugt für eine normale CSS-Box einen Stapelkontext, garantiert aber keine eigene Compositing-Ebene. will-change ist ein Optimierungshinweis, keine Anweisung zur Ebenenerstellung; zusätzliche Ebenen können Speicher kosten.

Vergleiche dieselbe Bewegung mit left und transform. Eine Änderung von left kann Layout und Paint erfordern; eine transform-Animation kann allein durch Compositing verarbeitet werden. Prüfe diese Annahmen, statt sie als CSS-Garantien zu behandeln. Wiederhole die Messungen unter gleichen Bedingungen und prüfe die Ergebnisse auf den Zielgeräten. Namen und Verfügbarkeit der Werkzeuge hängen von Browser und Version ab.

Beispiele

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

Ergebnis

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.

Ändere nur den Animationsnamen von `move-left` zu `move-transform`. Prüfe, ob das Quadrat in derselben Zeit dieselbe Strecke zurücklegt, und vergleiche dann die Aufzeichnungen. Trifft `prefers-reduced-motion: no-preference` nicht zu, bleibt das Quadrat stehen.

Zugehörige Lektionen

  • CSS · Lektion 29 · Fortgeschritten · Version: 2

Quellen