Charger moins de travail
- Leçon 15
- 55 min
- Module 5 : Performance et capacité de croissance
Où nous en sommes
Dans la leçon précédente, nous avons mesuré le bureau. Sur un profil de téléphone, le téléchargement du JavaScript était la plus grande partie du premier chargement. Nous savons maintenant où travailler. Dans cette leçon, nous chargeons et dessinons seulement ce que l'agent voit : une page de données, les lignes visibles et le code de l'écran ouvert. Ensuite, nous mesurons ce que chaque changement économise. Pensez à un long rouleau de papier lu à travers une petite fenêtre.
Leçon 15 sur 19 · Architecture frontend et performance des applications d'IACharger moins de travail
1. Premiers pas avec le Web
2. Composants et structure de l'application
3. Récupération des données et gestion de l'état
4. États d'interaction propres à l'IA
5. Performance et capacité de croissance
6. Sécurité, accessibilité et remise du travail
Ce que vous saurez faire
L’écran de l’agent montre environ dix lignes de billets de soutien et une page du bureau. Chargez et dessinez seulement cela : une page de données, les lignes visibles et le code de l’écran ouvert. Mesurez ensuite ce que chaque changement économise et ce qu’il coûte.
Avant de commencerCe qu’il faut savoir et avoir sous la main
Ce que vous devez savoir
- Les trois types d’attente, le rapport de taille, le repère des premières lignes et les laboratoires, dans Mesurer dans le navigateur.
- Les pages serveur de 50 billets avec un curseur, dans Pagination et formulaires.
- Les promesses et
import, dans L’essentiel de JavaScript.
Ce qu’il vous faut sur votre ordinateur
- Votre projet après la dernière leçon :
npm testaffichepass 21etTests 42 passed (42), etnpm run sizefonctionne. - L’API simulée en marche dans un premier terminal (
npm run api), avec ses 10 000 billets (par défaut). - Une connexion Internet pour un
npm install.
Testé avec Node.js 24.18.0 et npm 11.16.0 sur macOS (Apple silicon), dans Chromium 156. Les commandes Windows (PowerShell) et Linux sont fournies, mais n’ont pas été exécutées.
Seulement ce qui passe par la fenêtre
Section intitulée « Seulement ce qui passe par la fenêtre »Imaginez un très long rouleau de papier avec une liste de noms : dix mille noms. Vous le lisez à travers un petit cadre de fenêtre qui montre dix noms à la fois. Pour poursuivre la lecture, vous faites défiler le papier. Personne n’a besoin de dérouler tout le papier sur le plancher pour lire dix noms.
Un plombier fait la même chose avec ses outils. La camionnette contient tous les outils, mais le plombier apporte seulement la boîte nécessaire au travail du jour dans la maison. S’il lui faut un outil rarement utilisé, il va alors le chercher dans la camionnette.
Cette leçon applique les deux idées au bureau. Affichez seulement les lignes qui entrent dans la fenêtre et envoyez seulement le code nécessaire à l’écran ouvert. Le reste demeure « dans la camionnette » jusqu’à ce que l’agent en ait besoin.
Ne téléchargez pas ce que personne ne verra
Section intitulée « Ne téléchargez pas ce que personne ne verra »La première économie, et la plus importante, concerne les données. C’est l’erreur introduite dans le cours : récupérer tout le jeu de données pour afficher une page. Le laboratoire de listes a un bouton qui le fait volontairement. Il demande tous les billets à l’API simulée, 100 à la fois. Sur le portable de l’équipe du cours, cela a pris 6 502,5 ms, 100 requêtes et environ 2 372 ko de JSON. Ce n’est qu’ensuite que la première ligne pouvait être dessinée. Le bureau demande plutôt une page de 50 billets et les dessine après une requête. Vous avez construit cela dans Pagination et formulaires; cette leçon le conserve.
Le temps de réponse des listes de l’API simulée est artificiel : 60 ms, plus un peu pour chaque résultat de recherche. Vos temps seront donc différents. La tendance restera la même : 100 requêtes prennent toujours plus de temps qu’une seule.
Le problème : des milliers de lignes à l’écran
Section intitulée « Le problème : des milliers de lignes à l’écran »Les pages de 50 règlent le téléchargement. Mais un agent qui fait défiler la liste continue de charger des pages, et les agents de Grace défilent beaucoup. Après 200 pages, la liste contient 10 000 billets. Si React les dessine tous, le navigateur contient une ligne par billet, même si l’écran en montre environ dix.
Le laboratoire de listes mesure cela. Il dessine les mêmes billets de deux façons : toutes les lignes ou seulement les lignes visibles. Il mesure le temps entre le clic sur Draw (dessiner) et le prochain affichage, puis compte les éléments de la page. Pour 10 000 lignes, dessiner toutes les lignes a pris 274,3 ms et placé 60 002 éléments dans la page. Pendant ces 274 ms, la page ne peut pas répondre à un clic ou à une touche.

L’idée : dessiner seulement les lignes visibles
Section intitulée « L’idée : dessiner seulement les lignes visibles »Le cadre de fenêtre du rouleau donne la réponse. La liste garde les 10 000 billets en mémoire, ce qui coûte peu : ce sont des données. Mais elle place seulement les lignes visibles dans la zone de défilement, plus quelques lignes au-dessus et en dessous. Quand l’agent fait défiler la liste, les mêmes quelques éléments de ligne reçoivent de nouveaux billets.
On appelle cela la virtualisation, ou une liste virtuelle. « Virtuelle » signifie que la liste semble complète : la barre de défilement a la longueur de 10 000 lignes. Mais la plupart des lignes n’existent pas dans la page. Elles sont créées quand elles deviennent visibles.
Un petit exemple : quelles lignes existent?
Section intitulée « Un petit exemple : quelles lignes existent? »La zone de défilement du bureau occupe 60 % de la hauteur de la fenêtre. Dans une fenêtre de 900 px de haut, cela donne 540 px. Chaque ligne mesure 56 px de haut.
- Lignes visibles : 540 ÷ 56 = 9,6, donc 10 lignes sont affichées, la dernière en partie.
- La liste ajoute 8 lignes en dessous et au-dessus (la marge de rendu, ou overscan). Ainsi, un défilement rapide ne montre jamais de vide. Au début de la liste, il n’y a rien au-dessus. Elle dessine donc les lignes 0 à 17 : 18 lignes.
- Chaque ligne compte 6 éléments : l’élément de liste, le lien, trois textes et l’insigne. Les 18 lignes donnent donc 18 × 6 = 108 éléments, plus la liste et la zone de défilement : 110 éléments. C’est le nombre que le laboratoire a compté, pour 100 lignes comme pour 10 000.
- Pour garder une barre de défilement fidèle, la liste a la hauteur de toutes les lignes : 10 000 × 56 = 560 000 px. Chaque ligne dessinée est déplacée à sa position : la ligne 35 commence à 35 × 56 = 1 960 px.
Quand l’agent descend de 2 000 px, les lignes 35 à 45 sont visibles : 2 000 ÷ 56 = 35,7, et (2 000 + 540) ÷ 56 = 45,4. Avec 8 lignes de marge de rendu de chaque côté, la page contient les lignes 27 à 53. Les 9 973 autres billets restent seulement des données.
Exploration : quand est-ce utile?
Section intitulée « Exploration : quand est-ce utile? »Explorer
Toutes les lignes ou seulement les lignes visibles?
Prédisez d’abord : À partir de combien de lignes leur dessin devient-il lent : 100, 1 000, 5 000 ou 10 000?
- Chaque ligne : temps, éléments
- 34,5 ms, 6 002
- Lignes visibles : temps, éléments
- 29,7 ms, 110
- Chaque ligne ÷ lignes visibles
- 1,2 × le temps, 55 × les éléments
À 1 000 lignes, les deux façons sont proches : 34,5 ms contre 29,7 ms. Les deux sont près du temps le plus court que la mesure peut montrer. La virtualisation n’apporte presque rien ici.
Temps du clic à l’écran
environ 29 ms : le temps le plus court que cette mesure peut montrer (elle attend deux images)
100 ms : en dessous, un clic semble immédiat
Éléments dans la page
Le labo de liste de ticket-desk dans Chromium, fenêtre 1280 × 900. Médiane de 5 mesures sur l’ordinateur de l’équipe du cours ; vos temps seront différents, la forme reste.
Description textuelle de l’explorateur
L’explorateur a une commande : le nombre de lignes, 100, 1 000, 5 000 ou 10 000. Pour chaque nombre, il montre deux paires de barres. La première paire mesure le temps entre le clic sur Draw et l’affichage. Dessiner toutes les lignes a pris 30,4 ms pour 100 lignes, 34,5 ms pour 1 000, 138,7 ms pour 5 000 et 274,3 ms pour 10 000. Dessiner seulement les lignes visibles a pris entre 29,1 et 30,1 ms à chaque taille. Environ 29 ms est le temps le plus court que cette mesure peut montrer, car elle attend deux images d’écran. Une ligne pointillée marque 100 ms, seuil sous lequel un clic semble instantané. La deuxième paire montre les éléments dans la page : 602, 6 002, 30 002 et 60 002 pour toutes les lignes. Pour les lignes visibles, c’est 110 à chaque taille.
Jusqu’à 1 000 lignes, les deux façons sont presque identiques : 34,5 ms contre 29,7 ms. À 5 000 lignes, dessiner toutes les lignes dépasse 100 ms. Sous ce seuil, un clic semble instantané pour la plupart des gens. À 10 000, c’est dix fois plus lent que la liste virtuelle. Virtualisez pour des milliers de lignes, pas pour des centaines.
Le bureau : une liste virtuelle de billets
Section intitulée « Le bureau : une liste virtuelle de billets »Le bureau utilise TanStack Virtual, une petite bibliothèque de la même famille que TanStack Query. Son hook (fonction React) useVirtualizer fait les calculs du petit exemple. Vous lui donnez le nombre de lignes, la zone de défilement et la hauteur d’une ligne. Il renvoie les lignes à dessiner et la position de chacune. Voici les lignes importantes du nouveau TicketList.tsx :
const ROW_HEIGHT = 56; // px, the height of .row in styles.css (3.5rem)
const scroller = useRef<HTMLDivElement>(null);const rows = useVirtualizer({ count: tickets.length, getScrollElement: () => scroller.current, estimateSize: () => ROW_HEIGHT, overscan: 8,});const visible = rows.getVirtualItems();
// Near the end of what is loaded: ask the server for the next page.const last = visible.at(-1)?.index ?? 0;const { hasNextPage, isFetchingNextPage, fetchNextPage } = list;useEffect(() => { if (hasNextPage && !isFetchingNextPage && last >= tickets.length - 10) void fetchNextPage();}, [last, tickets.length, hasNextPage, isFetchingNextPage, fetchNextPage]);La liste dessine seulement visible, en déplaçant chaque ligne à sa position :
<div ref={scroller} className="scroller" tabIndex={0} role="region" aria-label="Ticket list"> <ul className="rows" style={{ height: rows.getTotalSize(), position: 'relative' }}> {visible.map((v) => { const t = tickets[v.index]; return ( <li key={t.ticket_id} style={{ position: 'absolute', top: 0, left: 0, right: 0, transform: `translateY(${v.start}px)` }}> <TicketRow ticket={t} selected={t.ticket_id === selectedId} /> </li> ); })} </ul></div>Deux choses ont changé ensemble. La liste dessine seulement les lignes visibles. Et elle demande elle-même la page suivante quand l’agent fait défiler la liste près de la fin. L’agent n’a jamais à appuyer sur Load 50 more (charger 50 billets de plus). Le bouton reste pour les personnes qui préfèrent utiliser le clavier. La zone de défilement a tabIndex={0}. Une personne peut donc l’atteindre avec Tab et la faire défiler avec les touches fléchées.

Quand virtualiser, et à quel coût
Section intitulée « Quand virtualiser, et à quel coût »- Utilisez la virtualisation quand une liste peut contenir des milliers de lignes, comme le bureau après un long défilement. Cela vaut aussi pour un journal ou un tableau de résultats de recherche.
- Ne l’utilisez pas pour une liste de quelques dizaines ou centaines de lignes. Les mesures ne montrent aucun gain jusqu’à 1 000 lignes. La bibliothèque coûte 9,1 ko de JavaScript (gzip) au premier téléchargement.
- Ce qu’elle coûte au-delà des octets. Les lignes doivent avoir une hauteur connue, sinon la bibliothèque doit mesurer chacune. La recherche du navigateur (Ctrl+F ou Cmd+F) trouve seulement les lignes qui existent dans la page. Un lecteur d’écran annonce une liste d’environ 18 éléments, pas 10 000. Une ligne qui a le focus du clavier disparaît quand elle sort de la zone visible. Chaque point demande de l’attention. La liste du bureau conserve le champ de recherche serveur pour trouver des billets. La leçon Interactions accessibles vérifie le parcours au clavier.
Envoyer seulement le code de l’écran ouvert
Section intitulée « Envoyer seulement le code de l’écran ouvert »La deuxième économie concerne le code. Dans la dernière leçon, le bureau formait un seul fichier JavaScript. Chaque agent le télécharge entièrement avant les premières lignes : la liste et le billet, mais aussi le formulaire de nouveau billet et les laboratoires. La plupart des agents ne les ouvrent jamais.
Le fractionnement du code divise le code en plusieurs fichiers. Le premier fichier contient ce dont le premier écran a besoin. Chaque autre fichier contient un écran, et le navigateur le télécharge quand l’agent ouvre cet écran. Comme les outils dans la camionnette du plombier, les autres fichiers attendent que quelqu’un en ait besoin.
JavaScript offre une façon intégrée de charger du code plus tard : import() avec des parenthèses, un import dynamique. Il renvoie une promesse qui se résout quand le fichier arrive. Vite repère chaque import dynamique et crée un fichier séparé pour chacun. React enveloppe cela dans lazy(), et <Suspense> indique quoi afficher pendant l’arrivée du fichier :
import { lazy, Suspense } from 'react';
// Loaded only when the agent opens them (code splitting): the ticket list does not wait for them.const NewTicketForm = lazy(() => import('./features/jobs/NewTicketForm').then((m) => ({ default: m.NewTicketForm })));const LabsPage = lazy(() => import('./labs/LabsPage').then((m) => ({ default: m.LabsPage })));<Suspense fallback={<p className="muted">Loading the page…</p>}> {route.page === 'new' && <NewTicketForm />} {route.page === 'labs' && <LabsPage lab={route.lab} />}</Suspense>lazy() attend un module avec un export default (par défaut). Les composants du bureau sont des exports nommés. Ainsi, .then((m) => ({ default: m.NewTicketForm })) lui donne cette forme.
Description textuelle du diagramme
Avant le fractionnement du code, le bureau forme un seul fichier JavaScript de 96.78 ko sur le réseau. Chaque agent le télécharge entièrement avant les premières lignes. Après le fractionnement, le premier fichier contient le premier écran : 93.02 ko. Trois autres fichiers sont téléchargés seulement quand l’agent ouvre la page correspondante : LabsPage.js (3.77 kB, the labs); NewTicketForm.js (1.74 kB, a new ticket); useJob.js (0.51 kB, a new ticket or the job lab).
Combien a-t-on économisé? Mesurez-le
Section intitulée « Combien a-t-on économisé? Mesurez-le »À votre étape, le fractionnement économise 3.76 ko au premier téléchargement : 96.78 ko avant, 93.02 ko après. C’est environ 4 %. Le formulaire de nouveau billet et les laboratoires sont petits. React, nécessaire au premier écran, occupe la plus grande partie du fichier. Avec le profil simulant un téléphone, l’équipe du cours a mesuré l’arrivée des premières lignes à 1117.2 ms avec un seul fichier et 1102.1 ms après fractionnement (médiane de 5 essais). That is 15.1 ms sooner, but the runs spread from 1,094.4 to 1,127.1 ms and from 1,094.4 to 1,123.5 ms: the difference is smaller than the spread, so it is not a real change.
Le fractionnement est utile quand une grande partie du code sert à un seul écran. Dans Limites de sécurité du navigateur, le brouillon reçoit deux bibliothèques qui transforment le Markdown du modèle en HTML sûr. Elles représentent 24,6 ko sur le réseau et servent seulement quand un agent ouvre un brouillon. L’équipe du cours a mesuré le bureau terminé des deux façons :
Description textuelle du graphique
Premières lignes du bureau terminé. Sur un réseau rapide : 98,2 ms avec un fichier unique et 97,2 ms avec des fichiers séparés, sans différence réelle. Avec le profil simulant un téléphone : 1 256,5 ms avec un fichier unique et 1 113 ms avec des fichiers séparés. Le premier fichier séparé représente 92,4 ko plutôt que 123,2 ko sur le réseau : 30,8 ko de moins.
Sur un réseau rapide, l’économie de 30,8 ko ne change rien de visible : 98 ms contre 97 ms. Avec le profil simulant un téléphone, les premières lignes arrivent 144 ms plus tôt (1 256,5 contre 1 113 ms). Le fractionnement du code n’est donc pas une règle à appliquer partout. Il vaut la peine quand le code déplacé est volumineux et que vos utilisateurs ont des réseaux lents.
Ce qu’il coûte. Chaque fichier séparé ajoute une requête quand l’agent ouvre cet écran. La première visite aux laboratoires attend donc son fichier. Un contenu de remplacement <Suspense> apparaît pendant cette attente. Trop de petits fichiers peuvent être plus lents qu’un gros fichier, car chaque requête fait un aller-retour. Fractionnez par écran et par grande bibliothèque, pas par composant.
Images et polices : envoyer la taille affichée
Section intitulée « Images et polices : envoyer la taille affichée »Le bureau n’a pas d’images et utilise les polices de l’ordinateur. Il n’a donc rien à corriger ici. La plupart des produits en ont, et l’idée reste la même : n’envoyez pas plus que ce que l’écran affiche.
Prenez une photo d’un téléphone : 4 000 × 3 000 pixels, souvent de 3 à 5 Mo. Une page d’aide l’affiche à 400 × 300 pixels. Le fichier contient 4 000 × 3 000 = 12 000 000 pixels, et l’écran en affiche 400 × 300 = 120 000. Donc, 99 % des pixels sont téléchargés pour rien. Sur un réseau téléphonique de 1,6 Mbit/s, 3 Mo représentent 24 000 kilobits, soit environ 15 secondes.
- Donnez à chaque image la taille affichée, ou une taille un peu plus grande pour les écrans haute résolution. L’attribut
srcsetde<img>permet au navigateur de choisir parmi les tailles. - Utilisez un format compressé : WebP ou AVIF pour les photos, SVG pour les icônes et les diagrammes.
- Donnez à chaque image ses attributs
widthetheight. La page réserve ainsi l’espace et ne bouge pas à son arrivée. - Ajoutez
loading="lazy"aux images sous le premier écran : le navigateur les charge quand elles approchent de la zone visible. - Polices : utilisez les polices du système, comme le bureau, ou un fichier de police dans un format moderne (WOFF2). Gardez seulement les graisses utilisées.
Exercice guidé : une liste virtuelle et deux écrans à chargement différé
Section intitulée « Exercice guidé : une liste virtuelle et deux écrans à chargement différé »Travaillez dans ~/projects/ticket-desk, avec l’API simulée en marche dans un premier terminal.
-
Ajoutez TanStack Virtual, à la version exacte du cours :
Fenêtre de terminal npm install @tanstack/react-virtual@3.14.15 --save-exact -
Copiez la nouvelle liste de billets, son test et le laboratoire de listes depuis l’instantané :
Fenêtre de terminal S=../nextia-learning-labs/C22/snapshots/end-of-m05cp $S/src/features/tickets/TicketList.tsx $S/src/features/tickets/TicketList.test.tsx src/features/tickets/cp $S/src/labs/ListLab.tsx src/labs/Fenêtre de terminal $S = "..\nextia-learning-labs\C22\snapshots\end-of-m05"Copy-Item "$S\src\features\tickets\TicketList.tsx", "$S\src\features\tickets\TicketList.test.tsx" src\features\tickets\Copy-Item "$S\src\labs\ListLab.tsx" src\labs\Ouvrez
TicketList.tsxet trouvez les parties montrées plus haut :useVirtualizer, l’effet qui charge la page suivante et leulavec sa hauteur totale. Le nouveau test vérifie que 50 billets chargés donnent moins de 25 lignes dans la page. -
Dans
src/labs/LabsPage.tsx, importez le laboratoire de listes et ajoutez-le àLABS, avant la lignererender:import { ListLab } from './ListLab';list: { title: 'Thousands of rows', Lab: ListLab }, -
Exécutez
npm test, puisnpm run buildetnpm run size. Notez la taille du fichier JavaScript unique. -
Dans
src/App.tsx, supprimez les deux lignes d’import deNewTicketFormet deLabsPage. Ajoutezimport { lazy, Suspense } from 'react';comme première ligne. Ajoutez les deux ligneslazy()ci-dessus après la dernière ligne d’import. -
Dans le même fichier, placez les deux lignes
route.page === 'new'etroute.page === 'labs'dans l’élément<Suspense>montré ci-dessus. -
Exécutez à nouveau
npm run buildetnpm run size. Comparez le premier fichier avec celui de l’étape 4. -
Exécutez
npm run previewet ouvrez http://localhost:4173/#/labs/list. Appuyez sur Download every ticket (télécharger tous les billets). Dessinez ensuite 10 000 lignes, d’abord avec Every row, puis avec Only the rows in view. -
Ouvrez http://localhost:4173/ et faites défiler rapidement la liste de billets vers le bas. Observez la ligne « Showing … tickets » (nombre de billets affichés) au-dessus de la liste.
Afficher le résultat attendu
Étape 1, l’exécution de l’équipe du cours (npm peut afficher d’autres lignes sur le financement ou les scripts d’installation) :
added 2 packages, and audited 109 packages in 471mspackage.json contient maintenant "@tanstack/react-virtual": "3.14.15" dans "dependencies". npm a aussi ajouté @tanstack/virtual-core, la partie qui ne dépend pas de React.
Étape 4 : Tests 43 passed (43) après pass 21. La construction produit un seul fichier JavaScript :
dist/assets/index-B1ei4yzs.js 316.47 kB │ gzip: 96.78 kBIl a grossi d’environ 9 ko depuis la dernière leçon : c’est TanStack Virtual et le laboratoire de listes.
Étape 7 :
dist/index.html 0.39 kB │ gzip: 0.26 kBdist/assets/index-Cq7Ckq9E.css 4.20 kB │ gzip: 1.48 kBdist/assets/useJob-Lm28qjUm.js 0.89 kB │ gzip: 0.51 kBdist/assets/NewTicketForm-PDD-uc_E.js 4.14 kB │ gzip: 1.74 kBdist/assets/LabsPage-tEFacUpU.js 11.67 kB │ gzip: 3.77 kBdist/assets/index-DnbxJFGT.js 302.28 kB │ gzip: 93.02 kBJavaScript: 4 files, 95.6 KB gzip in allQuatre fichiers maintenant. useJob.js est partagé par le formulaire de nouveau billet et le laboratoire de tâches. Vite l’a donc placé dans son propre fichier. Ensemble, les fichiers sont un peu plus gros que le fichier unique. Chaque fichier contient un peu de code pour charger les autres. C’est acceptable : le premier écran télécharge seulement index.js.
Étape 8, sur le portable de l’équipe du cours (un essai de la version de profilage, donc les temps diffèrent un peu des médianes ci-dessus) :
10000 tickets in 100 requests, 6381.4 ms, about 2372 KB of JSON.10000 rows (every row): on the screen after 319.9 ms; 60002 elements in the page.10000 rows (only the rows in view): on the screen after 31.3 ms; 110 elements in the page.Étape 9 : le nombre augmente de 50 chaque fois que vous approchez de la fin : Showing 100 tickets (more on the server). (100 billets affichés, d’autres sur le serveur), puis 150, et ainsi de suite. Dans le panneau Network (réseau), une nouvelle requête tickets?limit=50&after=… apparaît chaque fois.
À vous de jouer : séparer aussi la vue du billet?
Section intitulée « À vous de jouer : séparer aussi la vue du billet? »Tomás aime le résultat : « Rendons aussi TicketView à chargement différé. C’est un écran complet. » Faites d’abord une prédiction. Le bureau s’ouvre souvent sur un billet de soutien, à partir d’un lien comme http://localhost:4173/#/tickets/T-80008. Ce billet apparaîtra-t-il plus tôt ou plus tard sur un téléphone?
Essayez : dans App.tsx, rendez TicketView à chargement différé de la même façon, puis enveloppez sa ligne dans un deuxième <Suspense>. Construisez l’application, lancez le rapport de taille, puis chargez le lien ci-dessus trois fois avec Slow 4G (4G lente) et un processeur ralenti 4×. Utilisez le panneau Performance (performance) ou observez l’écran.
Afficher la réponse
Il apparaît plus tard. Sur le portable de l’équipe du cours, avec le profil simulant un téléphone (médiane de 5 essais), voici les résultats. Le billet apparaissait après 1 304,1 ms avec TicketView à chargement différé, contre 1 039,7 ms sans : 264 ms plus tard. Les plages ne se chevauchent pas (de 1 287,9 à 1 305,6 ms, contre 1 038 à 1 055,8 ms).
Le diagramme en cascade montre pourquoi. index.js a perdu 2,5 ko (90,54 ko au lieu de 93,02 ko avec gzip). Il est donc arrivé quelques millisecondes plus tôt. Mais le navigateur peut demander TicketView.js seulement après l’arrivée et l’exécution de index.js. React doit aussi avoir déterminé qu’il a besoin de la vue du billet. Le nouveau fichier a été demandé à 812 ms et est arrivé à 987 ms. C’est un aller-retour de plus sur le réseau du téléphone, dans une chaîne. Le chargement différé transforme le travail parallèle en une chaîne. Cela ne coûte rien pour un écran que l’agent ouvre plus tard, mais beaucoup pour celui qu’il ouvre en premier.
La réponse est donc non. Un écran qui est souvent le premier doit rester dans le premier fichier. Annulez le changement : git checkout src/App.tsx, ou copiez App.tsx depuis l’instantané end-of-m05.
Erreur courante
Une liste virtuelle qui affiche toutes les lignes
Symptôme : un collègue modifie le CSS de la liste des billets et retire la hauteur de .scroller. Il veut que la liste « utilise toute la page ». La liste fonctionne toujours et les tests dans jsdom réussissent encore. Mais dans le laboratoire des listes, Only the rows in view (seulement les lignes visibles) avec 1 000 lignes produit maintenant 6 002 éléments, au lieu de 110. C’est exactement le même nombre qu’en affichant toutes les lignes. Sur le portable de l’équipe du cours, le temps est resté autour de 32 ms, car 1 000 lignes coûtent encore peu. À 10 000 lignes, ce serait aussi lent que de toutes les afficher.
Cause : le système de virtualisation affiche les lignes qui tiennent dans la zone de défilement. Sans hauteur fixe, la zone grandit jusqu’à la hauteur de la liste : 1 000 × 56 = 56 000 px. Toutes les lignes sont donc « visibles ». Rien ne plante, donc rien ne vous avertit.
Correction : donnez une hauteur fixe à l’élément de défilement (le bureau utilise height: 60vh) et ajoutez overflow: auto. Vérifiez les éléments de la page après chaque modification du CSS de la liste. Dans la Console (console), document.querySelectorAll('.scroller li').length devrait être autour de 18, pas de 1 000.
Conséquence dans le travail en IA : les longues listes sont courantes dans les interfaces d’IA. Pensez à un historique de conversation, aux résultats d’un système de récupération ou à un journal d’appels de modèle. Une liste virtuelle qui affiche tout sans avertissement réussit tous les tests fonctionnels. Elle échoue seulement lorsqu’un utilisateur réel a un long historique.
Vérification des connaissances
Section intitulée « Vérification des connaissances »Vérifiez votre compréhension
Un collègue veut virtualiser la zone « Recent tickets » (billets récents), qui affiche toujours les 20 derniers billets. Que répondez-vous, avec des chiffres?
Afficher la réponse
Ne la virtualisez pas. Jusqu’à 1 000 lignes, tout afficher était à peu près aussi rapide que la liste virtuelle : 34,5 contre 29,7 ms. À 100 lignes, c’était 30,4 contre 29,1 ms. Pour 20 lignes, le gain n’est pas mesurable. La bibliothèque ajouterait 9,1 ko au premier téléchargement. La zone perdrait aussi la recherche du navigateur et une liste simple pour les lecteurs d’écran. Virtualisez pour des milliers de lignes, pas des dizaines.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Vérifiez votre compréhension
Faites une prédiction : vous séparez un écran dont le fichier fait 2 ko. Sur un réseau de bureau rapide, combien de temps gagnerez-vous avant l'affichage du premier écran? Et sur un réseau simulant un téléphone?
Afficher la réponse
Sur un réseau rapide, rien de visible : même 30,8 ko de moins ont fait passer les premières lignes de 98,2 à 97,2 ms. Avec le profil simulant un téléphone, 2 ko représentent environ 10 ms de téléchargement à 1,6 Mbit/s. Le calcul : 2 × 8 = 16 kilobits, soit environ 0,01 s. C’est moins que la différence entre deux essais. La séparation est utile pour les grandes parties du code utilisées par un seul écran. Dans le bureau terminé, les fichiers séparés contiennent 30,8 ko, surtout les bibliothèques Markdown du brouillon (24,6 ko). Les premières lignes sont apparues 144 ms plus tôt avec le profil simulant un téléphone.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Vérifiez votre compréhension
Pourquoi la zone de défilement du bureau doit-elle avoir une hauteur pour que la liste virtuelle fonctionne?
Afficher la réponse
Le système de virtualisation affiche les lignes qui tiennent dans la hauteur de la zone de défilement. Cela donne 540 px ÷ 56 px = 10 lignes, plus les lignes supplémentaires hors de la zone visible. Sans hauteur fixe, la zone grandit jusqu’à la hauteur de toute la liste. Toutes les lignes sont « visibles », et le système de virtualisation les affiche toutes. La liste fonctionne alors, mais elle est aussi lente qu’une liste simple.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Récapitulatif
- Données : demandez une seule page, jamais tous les billets. Télécharger les 10 000 billets a demandé 100 requêtes, environ 2 372 ko et 6 502,5 ms avant la première ligne.
- Affichage : une liste virtuelle place seulement les lignes visibles dans la page : 110 éléments et environ 30 ms, quelle que soit la taille. Cela se compare à 60 002 éléments et 274,3 ms pour 10 000 lignes. Jusqu’à 1 000 lignes, il n’y a aucun gain réel; virtualisez pour des milliers de lignes.
- Code :
lazy()et<Suspense>séparent le code par écran. À cette étape, cela a économisé 3.76 ko sur le premier téléchargement. Dans le bureau terminé, avec les bibliothèques Markdown du brouillon, la séparation a économisé 30,8 ko. Les premières lignes apparaissaient 144 ms plus tôt avec le profil simulant un téléphone, sans changement sur un réseau rapide. - Gardez le premier écran dans le premier fichier :
TicketViewà chargement différé a ralenti l’ouverture d’un lien direct vers un billet. - Images et polices : envoyez la taille affichée, dans un format compressé, avec
widthetheight.
Ensuite, vous passez des changements isolés à une vue d’ensemble de l’architecture. Le bureau devrait-il être rendu dans le navigateur, ou plutôt sur un serveur?
Leçon suivante : Décisions d'architecture