Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / CSS

Performances du rendu dans les DevTools : captures, FPS, Paint flashing et Layers

Les captures montrent l’apparence, les FPS indiquent la cadence, Paint flashing signale les zones peintes et Layers montre les calques de composition. Aucun de ces signaux ne constitue une garantie de performances déduite du seul CSS.

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

Syntaxe

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.

Un enregistrement Performance fournit une chronologie où rechercher les événements de calcul des styles, de mise en page (layout) et de peinture (paint). Si l’option est disponible, Screenshots ajoute une pellicule de captures prises à certains instants. Rapprochez-les des événements de la trace : elles ne couvrent pas toutes les images et ne mesurent pas le coût du rendu.

Les FPS sont le nombre d’images par seconde. Examinez aussi les durées image par image : une bonne moyenne peut masquer des saccades ponctuelles. À 60 Hz, environ 16,7 ms séparent deux rafraîchissements ; ce n’est pas un budget universel. Paint flashing surligne les zones peintes ou repeintes pendant l’observation, sans chronométrer le travail. Sans surbrillance, le moteur de composition peut tout de même assembler du contenu déjà peint.

Layers montre les calques du moteur de composition, et non les couches de cascade CSS (@layer) ni les contextes d’empilement. Pour une boîte CSS ordinaire, un transform autre que none crée un contexte d’empilement sans garantir un calque de composition distinct. will-change est un indice d’optimisation, pas un ordre de créer un calque ; des calques supplémentaires peuvent consommer de la mémoire.

Comparez le même déplacement avec left et transform. Modifier left peut nécessiter une mise en page et une peinture ; animer transform peut ne demander que de la composition. Ce sont des hypothèses à vérifier, pas des garanties du CSS. Répétez les mesures dans les mêmes conditions et vérifiez les résultats sur les appareils cibles. Les noms et la disponibilité des outils varient selon le navigateur et sa version.

Exemples

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

Résultat

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.

Changez uniquement le nom de l’animation de `move-left` à `move-transform`. Vérifiez que le carré parcourt la même distance dans le même temps, puis comparez les traces. Si `prefers-reduced-motion: no-preference` ne correspond pas, le carré reste immobile.

Leçons associées

  • CSS · Leçon 29 · Avancé · Version : 2

Sources