Rendu du navigateur : du texte aux images

L’écran dessiné n’est pas magique

Lorsque j’ai commencé le développement front-end (Vue.js), je considérais le navigateur comme un simple « cadre pour afficher le code ». Il était naturel que si vous utilisiez

, un carré apparaisse, et si vous utilisiez color: red, il deviendrait rouge.

Cependant, mes pensées ont changé à mesure que j’expérimentais le bégaiement de l’animation ou les secousses de l’écran lors du défilement (jank). « Pourquoi le même code s’exécute-t-il correctement dans Chrome mais plante-t-il dans Internet Explorer (IE) ? » « Pourquoi mon processeur monte-t-il en flèche lorsque je change un peu le style avec JavaScript ? »

Il s’avère que le navigateur n’est pas seulement un cadre photo. Le navigateur était un énorme « Peintre » et « Architecte » qui interprétait le texte (HTML/CSS) que nous envoyions, calculait mathématiquement chaque pixel et l’imprimait.

La dernière fois, nous avons transmis des données en toute sécurité sur des routes difficiles. Cette fois, ouvrons la boîte de données (paquet) qui est arrivée et découvrons comment le navigateur dessine une image appelée écran. Il s’agit de la dernière histoire de la série Re : Booting CS Basics.

Le navigateur est un chantier de construction où le code est lu, construit et peint.

La cargaison est arrivée, l’assemblage commence

Dans notre vision du monde du « centre logistique numérique », le produit (fichier HTML) est désormais arrivé chez le client (navigateur). Cependant, ce qui est arrivé n’était pas un produit fini, mais un « manuel de montage ». L’équipe de travail appelée moteur de navigateur (moteur de rendu) lit ce manuel et commence immédiatement l’assemblage. Ce processus est appelé pipeline de rendu.

Étape 1 : analyse du plan (analyse et arborescence DOM)

Lit le texte HTML qui arrive en premier et crée un « squelette ».

  • <html> est la racine (Root), <body> le tronc, <div> les branches…
  • Cette structure en arbre (Tree) s’appelle le DOM (Document Object Model). C’est aussi l’API qui permettra ensuite à JavaScript de manipuler ce squelette.

Étape 2 : Design d’intérieur (arborescence CSSOM)

Ensuite, lisez le fichier CSS et créez des « règles de style ».

  • « Tous les div sont rouges », « Les éléments de classe box mesurent 100px »
  • C’est ce qu’on appelle le CSSOM (CSS Object Model).

Étape 3 : Créer un bon de travail (Render Tree)

Maintenant, nous combinons le squelette (DOM) et la conception (CSSOM). Le point important ici est que seules les « éléments qui apparaîtront réellement à l’écran » sont sélectionnées.

  • Et un élément doté de la propriété display: none ? Comme il ne sera pas visible à l’écran, il est exclu de l’arbre de rendu. (Il n’occupe pas non plus d’espace)
  • En revanche, visibility: hidden ? L’élément est invisible mais occupe toujours de l’espace, il est donc inclus dans l’arbre de rendu.
L’arbre de rendu est une liste finale de « ceux qui peuvent être dessinés pour de vrai ».

[Vérification du code] Reflow et repaint

C’est maintenant l’étape vraiment importante. La clé de l’optimisation des performances réside ici. Une fois l’arbre de rendu créé, le navigateur effectue deux tâches lourdes.

  1. Mise en page (Layout) / Redistribution (Reflow) : calcule mathématiquement « où et à quelle taille » chaque élément sera placé. (La conception architecturale)
  2. Peinture (Paint) / Repeinture (Repaint) : applique réellement « la couleur » aux emplacements calculés. (Les travaux de peinture)

Tentons la différence de coût avec le code.

const box = document.getElementById('box');

// Case 1: Code qui declenche le layout (Reflow) (couteux !)
// Si la taille ou la position change, les elements voisins doivent tous etre recalcules.
box.style.width = '200px'; 
box.style.height = '200px';
box.style.margin = '20px';

// Case 2: Code qui declenche seulement le paint (Repaint) (relativement bon marche)
// Position inchangee, seule la couleur change. Pas de calcul, juste un repaint.
box.style.backgroundColor = 'blue';
box.style.color = 'white';
box.style.visibility = 'hidden';

Analyse :

  • Modification de width : ce sont des travaux qui changent la taille du bâtiment. Le bâtiment voisin est repoussé, puis celui d’à côté aussi. Le navigateur doit refaire tous ses calculs. (Reflow déclenché -> principal responsable des baisses de performances)
  • Modification de color : la taille du bâtiment ne change pas, on se contente de le repeindre. Aucun calcul n’est nécessaire. (Repaint déclenché -> rapide)

En pratique, la plupart des cas d’« animation saccadée » se produisent parce que les propriétés de mise en page telles que width, left et top sont touchées en temps réel. Dans ce cas, une technique est nécessaire pour ignorer le calcul de mise en page en utilisant des propriétés telles que transform.

Conseil pratique : ne malmenez pas votre navigateur

Je ne le savais pas quand j’étais à l’université, alors j’ai manipulé le DOM au hasard avec JavaScript. En parcourant l’instruction for, j’ai modifié la taille et le style de chaque élément. Du point de vue du navigateur, c’est comme être torturé en détruisant et en reconstruisant un bâtiment des dizaines de fois par seconde.

Conseils pour garantir les performances :

  1. Regroupez les manipulations du DOM : au lieu de modifier les styles un par un, préparez une class à l’avance et changez simplement className, une seule fois.
  2. Confiez les animations au GPU : en remplaçant left et top par transform: translate(), l’étape de mise en page est sautée et c’est le GPU qui s’en charge.
  3. La différence pour masquer : faites bien la distinction entre display: none (exclu de l’arbre de rendu) pour supprimer complètement un élément, et visibility: hidden (inclus dans l’arbre de rendu) pour simplement laisser sa place vide.
Changer l’emplacement (Reflow) est une opération beaucoup plus coûteuse que changer la couleur (Repaint).

Fin de la série 1 : mon CS redémarré

Avec cet article, la [Re: Booting] CS Basics Series a pris fin.

Nous avons fait un long voyage ensemble.

  1. Langage (Language) : le code écrit par un humain a été traduit en langage machine (build),
  2. Mémoire (Memory) : il a emménagé dans les pièces appelées Stack et Heap,
  3. Processus (OS) : il s’est partagé le CPU grâce à la technique du clonage appelée thread,
  4. Réseau (Network) : découpé en paquets, il a parcouru des routes difficiles,
  5. Rendu (Rendering) : puis il a rencontré un peintre nommé navigateur, et c’est enfin là qu’il est apparu sous nos yeux.

Au début, c’était juste des connaissances que j’avais mémorisées pour trouver un emploi. Cependant, après avoir rencontré des erreurs dans la pratique et après avoir regardé à nouveau, CS (ingénierie informatique) n’était pas une lettre morte, mais une terre solide qui soutenait mon code.

Les travaux de fondation sont maintenant terminés. Il est temps de construire votre propre château sur des bases solides. Dans la prochaine série [Monolith Builder], j’aborderai la création d’applications Web à l’aide de Spring Boot et Vue.js, que j’ai expérimenté en pratique. Veuillez attendre avec impatience le processus de transformation de la « théorie » en « pratique ».

Laisser un commentaire