Mesurer dans le navigateur
- Leçon 14
- 55 min
- Module 5 : Performance et capacité de croissance
Où nous en sommes
Dans le module 4, le bureau a appris à montrer le travail d'IA pendant qu'il se fait et quand il se termine. Maintenant, Omar dit que le bureau est lent sur son téléphone. Nous pourrions deviner une correction, mais corriger avant de mesurer change souvent la mauvaise chose. Dans cette leçon, nous trouvons ce qui le fait attendre : le téléchargement, le travail du navigateur ou l'API. Un repas lent au restaurant montre pourquoi nous chronométrons d'abord chaque étape.
Leçon 14 sur 19 · Architecture frontend et performance des applications d'IAMesurer dans le navigateur
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
Omar dit que le bureau des billets est lent sur son téléphone. Avant de modifier le code, trouvez ce qui le fait attendre : le téléchargement, le travail du navigateur ou l’API. Cette leçon mesure les trois avec les outils du navigateur et des chiffres.
Avant de commencerCe qu’il faut savoir et avoir sous la main
Ce que vous devez savoir
- Les composants, les propriétés, l’état et pourquoi React redessine un composant, dans Rendu et effets.
- La liste de billets par pages de 50, dans Pagination et formulaires.
- Le brouillon en flux continu et ses morceaux de texte, dans Interfaces en flux continu.
Ce qu’il vous faut sur votre ordinateur
- Votre projet
~/projects/ticket-deskà la fin du module 4 :npm testaffichepass 21etTests 40 passed (40). Sinon, copiez l’instantanéend-of-m04, comme l’indique le README des ateliers. - Chrome ou Edge. Leurs outils de développement (DevTools) sont identiques, car les deux reposent sur Chromium. Firefox propose les mêmes outils sous des noms légèrement différents.
- Facultatif : l’extension React Developer Tools pour votre navigateur, pour son onglet Profiler (profileur).
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.
Un restaurant lent
Section intitulée « Un restaurant lent »Vous commandez un repas, et il arrive 40 minutes plus tard. Qui a été lent? Le serveur a peut-être tardé à prendre votre commande. La cuisine était peut-être débordée. L’assiette était peut-être prête en 10 minutes, puis a attendu 25 minutes sur le comptoir.
Un nouveau gestionnaire qui achète un four plus rapide ne règle rien si les assiettes attendaient sur le comptoir. Un bon gestionnaire note d’abord l’heure de chaque étape pour quelques commandes : commande prise, cuisson commencée, assiette prête, assiette servie. L’étape lente devient alors visible, et le gestionnaire ne change que celle-là.
Une page Web fonctionne de la même façon. L’agent clique, puis quelque chose se produit plus tard. Entre le clic et l’affichage, il y a plusieurs étapes. Chacune peut être l’étape lente.
Le problème : corriger avant de mesurer
Section intitulée « Le problème : corriger avant de mesurer »Le message d’Omar est court : « Le bureau est lent sur mon téléphone. » Tomás répond aussitôt : « React redessine trop souvent. Mettons chaque composant dans memo. Mémoïsons tout. »
Vous avez vu memo et cette mesure dans Rendu et effets : memo indique à React d’ignorer un composant dont les propriétés n’ont pas changé. Teodor répète la mesure avec une page d’atelier que vous ajoutez dans cette leçon. La page contient une zone de note au-dessus de 50 lignes de billets. Teodor tape 20 caractères dans la note et compte combien de fois React redessine les lignes.
| Où se trouve le texte de la note | Lignes redessinées | Temps dans React pour 20 frappes |
|---|---|---|
| Dans le composant qui dessine aussi les lignes | 1 000 | 2,4 ms |
Au même endroit, avec chaque ligne dans memo |
0 | 0,7 ms |
| Dans un petit composant réservé à la note | 0 | 0,4 ms |
memo a économisé 1,7 ms pour 20 frappes : moins de 0,1 ms par touche, contre environ 16,7 ms entre deux images à l’écran. Déplacer l’état plus bas a économisé davantage, sans aucun memo.
La correction de Tomás allonge donc le code sans gain qu’Omar puisse percevoir. Elle répond à une question que personne n’a mesurée. Ce cours appelle cette erreur optimiser avant de mesurer le véritable goulot d’étranglement. Le goulot d’étranglement est l’étape qui détermine l’attente totale, comme le comptoir où les assiettes attendaient.
L’idée : trois types d’attente
Section intitulée « L’idée : trois types d’attente »Tout le temps entre l’action de l’agent et le résultat à l’écran constitue un délai visible pour l’utilisateur. Pour le bureau des billets, il vient de trois types d’attente :
- Téléchargement. Les octets circulent sur le réseau : le HTML, le JavaScript, le CSS, le JSON de l’API. Sur un réseau de bureau rapide, cette attente est courte. Sur un téléphone avec un signal faible, elle peut représenter la majeure partie de l’attente.
- Travail dans le navigateur. Le navigateur exécute le JavaScript. React détermine ce qui a changé, puis le navigateur calcule la disposition de la page et la dessine. Un téléphone lent fait ce travail plusieurs fois plus lentement qu’un portable.
- Attente de l’API. La requête part vers le serveur, le serveur travaille, puis la réponse revient. Le navigateur ne fait qu’attendre.
Description textuelle du diagramme
Le schéma montre les six étapes du premier chargement du bureau. D’abord, le navigateur demande la page. Le HTML arrive, mais ne contient qu’un élément vide portant l’identifiant root. Ensuite, le JavaScript arrive : React, les bibliothèques et le code du bureau. Le navigateur l’exécute, et React dessine la structure de la page. Le code demande 50 billets à l’API et attend le JSON. Enfin, React dessine les lignes. Les étapes 1 à 3 sont des téléchargements, mesurés avec le panneau Network et le rapport de taille. Les étapes 4 et 6 sont du travail dans le navigateur, mesuré avec le panneau Performance et le React Profiler. L’étape 5 est l’attente de l’API, mesurée avec le panneau Network.
Le navigateur peut vous dire quand chaque étape a eu lieu. Il enregistre les moments du chargement dans l’API Performance, un ensemble de chronomètres que chaque page peut lire en JavaScript. Trois de ces moments comptent ici :
- First Contentful Paint (FCP, premier affichage de contenu) : la première fois que l’écran affiche du texte ou une image. Pour le bureau, c’est le titre et « Loading tickets… » (chargement des billets).
- Largest Contentful Paint (LCP, affichage du plus grand contenu) : le moment où le plus grand bloc de texte ou la plus grande image apparaît. Les navigateurs s’en servent pour indiquer que le contenu principal est présent.
- DOMContentLoaded : le HTML est lu et les scripts qu’il contient ont été exécutés.
Aucun de ces moments ne tient compte des besoins d’un agent. « Loading tickets… » est du contenu pour le FCP, mais pas pour les agents de Grace. Le bureau définit donc son propre moment, une marque, au premier affichage des lignes de billets. Vous l’ajoutez dans l’exercice guidé :
performance.mark('tickets:first-rows');Le cours appelle ce moment premières lignes. C’est le chiffre à surveiller pour la plainte d’Omar.
Un petit exemple : un premier chargement, étape par étape
Section intitulée « Un petit exemple : un premier chargement, étape par étape »Voici un premier chargement du bureau après les changements de cette leçon, mesuré par l’équipe du cours. Le navigateur simulait un téléphone. Le réseau était ralenti selon le réglage « Slow 4G » (4G lente) de Chrome : 150 ms par aller-retour, 1,6 Mbit/s en téléchargement et 750 kbit/s en téléversement. L’ordinateur était ralenti au quart de sa vitesse. Ce sont les réglages pour téléphone de Lighthouse, l’outil de Google qui vérifie les pages Web.
Le graphique représente chaque requête par une barre, de la demande du navigateur jusqu’à l’arrivée du dernier octet. Ce type de graphique est une cascade, car les barres descendent depuis le coin supérieur gauche, comme l’eau sur des marches.
Description textuelle du diagramme
La cascade comporte quatre barres. La page elle-même, 0,7 ko de HTML, prend de 0 à 157 ms. Le fichier JavaScript index.js, 87,1 ko sur le réseau, prend de 163 à 751 ms : c’est de loin la barre la plus longue. Le fichier CSS, 1,8 ko, arrive en parallèle, avant 336 ms. Après un intervalle, la requête à l’API pour 50 billets s’étend de 839 à 1 065 ms. Trois lignes verticales marquent DOMContentLoaded à 786 ms, le FCP à 840 ms et les premières lignes à 1 074 ms.
Lisez le graphique depuis le haut, avec chaque chiffre :
- 0 à 157 ms : la page HTML, 0,7 ko. Presque tout ce temps correspond à l’aller-retour de 150 ms.
- 163 à 751 ms :
index.js, 87,1 ko. C’est la barre la plus longue : 588 ms. Le CSS, 1,8 ko, arrive en parallèle. - 751 à 839 ms : aucune barre. Le navigateur exécute le JavaScript, et React dessine la structure de la page. Le FCP arrive à 840 ms : le titre et « Loading tickets… ».
- 839 à 1 065 ms : la requête pour 50 billets, 226 ms. L’aller-retour représente 150 ms de ce temps.
- 1 074 ms : premières lignes. React a pris environ 9 ms pour les dessiner.
Vérifiez maintenant la barre la plus longue par un calcul. Le fichier JavaScript fait 87,1 ko sur le réseau. Un ko représente 1 000 octets, et un octet représente 8 bits, soit 697 kilobits. À 1,6 Mbit/s, environ 1 600 kilobits par seconde, il faut environ 0,44 seconde. Ajoutez un aller-retour de 0,15 seconde, et vous obtenez environ 0,59 seconde. La cascade indique 588 ms.
Sur les 1 074 ms avant les premières lignes, les téléchargements prennent donc 745 ms : le HTML et le JavaScript. L’API prend 226 ms, l’exécution du JavaScript environ 88 ms et le dessin des lignes environ 9 ms. Sur ce téléphone, le téléchargement représente environ les deux tiers de l’attente. C’est là qu’il faut chercher d’abord, dans la prochaine leçon. Le travail de React pour 50 lignes n’est pas le problème.
Le rapport de taille : ce que contient le JavaScript
Section intitulée « Le rapport de taille : ce que contient le JavaScript »Avant que le navigateur télécharge un fichier texte, le serveur le compresse généralement avec gzip. Le navigateur le décompresse ensuite. Un fichier a donc deux tailles. La taille sur le réseau (gzip) détermine le temps de téléchargement. La taille décompressée correspond à ce que le navigateur doit lire et exécuter. Vite affiche les deux après chaque construction :
dist/index.html 0.39 kB │ gzip: 0.26 kBdist/assets/index-Cq7Ckq9E.css 4.20 kB │ gzip: 1.48 kBdist/assets/index-D3f2JW_V.js 286.02 kB │ gzip: 87.72 kBTout le bureau tient dans un fichier JavaScript : 286 ko décompressés, 87,7 ko sur le réseau. Que contient-il? L’équipe du cours a construit le bureau terminé avec un fichier par paquet et a mesuré chacun. Les paquets ci-dessous ont actuellement les mêmes versions dans votre projet :
Description textuelle du graphique
La taille sur le réseau des paquets du JavaScript du bureau : react-dom 64,1 ko, le noyau de TanStack Query 9,5 ko et sa partie React 4,1 ko. Le paquet DOM de React représente à lui seul environ les trois quarts du fichier de 87,7 ko.
react-dom représente à lui seul 64,1 ko des 87,7 ko. Le code du bureau, avec tous ses écrans et ateliers, en représente une petite partie. Pour réduire le premier téléchargement, il faut donc exclure le code inutile au premier écran, mais pas React. La prochaine leçon fait exactement cela.
Temps de rendu : le React Profiler et les ateliers
Section intitulée « Temps de rendu : le React Profiler et les ateliers »Le panneau Performance de DevTools enregistre tout ce que fait le navigateur : scripts, disposition, dessin. React ajoute sa propre vue. Le React Profiler enregistre chaque rendu de React (un commit, ou validation) et le temps pris par chaque composant.
La construction normale de React pour la production retire le code de chronométrage pour rester petite et rapide. La construction de développement le conserve, mais fait des vérifications supplémentaires et est plus lente; ses temps sont donc trompeurs. La construction de profilage est le compromis : la vitesse de production, avec le code de chronométrage. Vous ajoutez un script pour elle dans l’exercice guidé, npm run build:profile. Les ateliers du bureau utilisent le composant <Profiler> de React pour compter les commits et mesurer le temps. Ils affichent les chiffres sur la page.
La trace des mises à jour des composants
Section intitulée « La trace des mises à jour des composants »Ce schéma suit une frappe dans la zone de note de l’atelier de nouveau rendu. Les composants orange sont redessinés; ceux en pointillés ne le sont pas.
Description textuelle du diagramme
Le schéma montre le même écran construit de trois façons. À gauche, l’état est trop haut. Le composant qui contient la note dessine aussi les lignes. Chaque frappe redessine donc ce composant, le champ, la liste et les 50 lignes. Pour 20 frappes, cela représente 1 000 rendus de lignes et 2,4 ms dans React. Au centre, les lignes sont enveloppées dans memo. Le parent et la liste sont toujours redessinés. React ignore les 50 lignes, car leurs propriétés n’ont pas changé : 0 rendu de ligne, 0,7 ms. À droite, la note se trouve dans son propre petit composant, NoteBox. Une frappe redessine seulement NoteBox et son champ; la liste reste intacte : 0 rendu de ligne, 0,4 ms.
Voici l’atelier de nouveau rendu sur le portable de l’équipe du cours, après 21 caractères tapés avec l’état trop haut :

Chaque morceau d’un flux
Section intitulée « Chaque morceau d’un flux »L’atelier de flux pose une question semblable sur le brouillon de l’IA. L’API simulée envoie le brouillon enregistré du billet T-64704 en 30 morceaux de texte. L’atelier redessine le texte à chaque morceau, ou une fois par image à l’écran. Dans ce dernier cas, il regroupe les morceaux arrivés pendant une image.
Description textuelle du graphique
Commits React pour un brouillon complet. Billet T-64704, 30 morceaux : 30 commits quand le texte est dessiné à chaque morceau, 11 quand il est dessiné une fois par image. Billet T-80008, 28 morceaux : 28 contre 12. Le temps de React pour un brouillon complet était inférieur à 0,01 ms dans tous les cas.
Dessiner une fois par image réduit les commits de plus de moitié. Mais le travail de React pour le brouillon complet était inférieur à 0,01 ms dans les deux cas. Le processeur ne justifie aucun changement ici. Il y a une vraie raison de ne pas réagir à chaque morceau, mais elle concerne une personne, pas un processeur : un lecteur d’écran qui lit chaque morceau à voix haute. C’est le sujet d’Interactions accessibles dans le module 6.

Exercice guidé : mesurer votre bureau
Section intitulée « Exercice guidé : mesurer votre bureau »Vous ajoutez quatre outils au projet : un rapport de taille, une version de profilage, le repère des premières lignes et deux laboratoires. Ensuite, vous mesurez un premier chargement simulant un téléphone dans DevTools. Travaillez dans ~/projects/ticket-desk. Gardez l’API simulée en marche dans un premier terminal (npm run api). Utilisez un deuxième terminal pour les commandes.
-
Ouvrez
package.json. Dans"scripts", après la ligne"test", ajoutez deux lignes. Mettez une virgule à la fin de la ligne"test"."build:profile": "tsc --noEmit && vite build --mode profile","size": "node scripts/bundle-report.mjs" -
Copiez le rapport de taille depuis l’instantané
end-of-m05. Les commandes supposent que le dépôt des laboratoires se trouve à côté de votre projet, dans~/projects.Fenêtre de terminal mkdir -p scriptscp ../nextia-learning-labs/C22/snapshots/end-of-m05/scripts/bundle-report.mjs scripts/Fenêtre de terminal New-Item -ItemType Directory -Force scriptsCopy-Item ..\nextia-learning-labs\C22\snapshots\end-of-m05\scripts\bundle-report.mjs scripts\Le script lit chaque fichier de
dist/, le compresse avec gzip et affiche les deux tailles. -
Remplacez
vite.config.tspar cette version. La nouvelle ligne utilise la version de profilage de React seulement quand la construction utilise--mode profile:import { defineConfig } from 'vitest/config';import react from '@vitejs/plugin-react';// `vite build --mode profile` builds the production code with React's profiling build, so that// the React DevTools Profiler (and <Profiler>) can measure a production build.export default defineConfig(({ mode }) => ({plugins: [react()],resolve: mode === 'profile' ? { alias: { 'react-dom/client': 'react-dom/profiling' } } : {},server: { port: 5173, strictPort: true },preview: { port: 4173, strictPort: true },test: {environment: 'jsdom',include: ['src/**/*.test.{ts,tsx}'],setupFiles: ['src/test/setup.ts'],},})); -
Dans
src/features/tickets/TicketList.tsx, importez aussiuseEffect:import { useEffect, useState } from 'react';. Ajoutez ensuite le repère après la ligneconst tickets = …:// A mark for the browser's performance tools: the first time that ticket rows are on the screen.const firstRows = tickets.length > 0;useEffect(() => {if (firstRows && performance.getEntriesByName('tickets:first-rows').length === 0) performance.mark('tickets:first-rows');}, [firstRows]);La vérification définit le repère une seule fois, à l’apparition des premières lignes.
-
Copiez les deux laboratoires, leur test et leur fonction de mesure du temps depuis l’instantané :
Fenêtre de terminal for f in measure.ts RerenderLab.tsx RerenderLab.test.tsx StreamLab.tsx; docp ../nextia-learning-labs/C22/snapshots/end-of-m05/src/labs/$f src/labs/doneFenêtre de terminal foreach ($f in 'measure.ts','RerenderLab.tsx','RerenderLab.test.tsx','StreamLab.tsx') {Copy-Item ..\nextia-learning-labs\C22\snapshots\end-of-m05\src\labs\$f src\labs\} -
Dans
src/labs/LabsPage.tsx, importez les deux laboratoires et ajoutez-les àLABS, après la lignejob:import { RerenderLab } from './RerenderLab';import { StreamLab } from './StreamLab';rerender: { title: 'Rows drawn again', Lab: RerenderLab },stream: { title: 'Draw every piece of a stream?', Lab: StreamLab }, -
Exécutez les tests :
npm test. Les deux nouveaux tests vérifient le laboratoire de rendu répété. Avec l’état trop haut, 5 frappes au clavier dessinent les 50 lignes 250 fois. Avec l’état déplacé plus bas, elles les dessinent 0 fois. -
Construisez l’application, puis exécutez le rapport de taille :
Fenêtre de terminal npm run buildnpm run size -
Démarrez la version de production :
npm run preview. Ouvrez http://localhost:4173/ dans Chrome ou Edge. -
Ouvrez DevTools (F12, ou Cmd+Option+I sur un Mac). Dans le panneau Network (réseau), sélectionnez Disable cache (désactiver le cache). Dans le menu de limitation, choisissez Slow 4G (4G lente). Dans le panneau Performance, ouvrez les paramètres (l’engrenage). Réglez CPU (processeur) sur 4× slowdown (ralentissement de 4×).
-
Rechargez la page. Dans le panneau Network, regardez les colonnes Waterfall (cascade) et Size (taille) de
index-….js. -
Dans le panneau Console, tapez
performance.getEntriesByName('tickets:first-rows')[0].startTimeet appuyez sur Entrée. -
Arrêtez l’aperçu (Ctrl+C). Exécutez
npm run build:profile, puis de nouveaunpm run preview. Ouvrez http://localhost:4173/#/labs/rerender, tapez 20 caractères dans la note et lisez les comptes. Faites la même chose avec les deux autres choix. -
Ouvrez http://localhost:4173/#/labs/stream et diffusez T-64704 en flux continu des deux façons.
-
Remettez la limitation du réseau et du processeur sur No throttling (aucune limitation). DevTools conserve ces réglages tant qu’il reste ouvert.
Afficher le résultat attendu
Étape 7 :
ℹ pass 21 Tests 42 passed (42)Étape 8, l’exécution de l’équipe du cours (vos noms de fichiers ont les mêmes empreintes si vos fichiers sont identiques) :
dist/index.html 0.39 kB │ gzip: 0.26 kBdist/assets/index-Cq7Ckq9E.css 4.20 kB │ gzip: 1.48 kBdist/assets/index-D3f2JW_V.js 286.02 kB │ gzip: 87.72 kB✓ built in 305msFile Size Gzipassets/index-D3f2JW_V.js 279.3 KB 84.6 KBassets/index-Cq7Ckq9E.css 4.1 KB 1.4 KBindex.html 0.4 KB 0.3 KBJavaScript: 1 files, 84.6 KB gzip in allLes deux outils donnent des résultats un peu différents, et les deux ont raison. Vite compte 1 kB comme 1 000 octets. Le rapport de taille compte 1 KB comme 1 024 octets. Il utilise aussi le réglage de compression maximal de gzip, comme beaucoup de serveurs. Comparez toujours des tailles provenant du même outil.
L’étape 9 affiche ➜ Local: http://localhost:4173/.
Étape 11 : après la page viennent trois requêtes : index-….js d’environ 87 ko, le fichier CSS et tickets?limit=50. La requête API commence seulement après l’arrivée et l’exécution du JavaScript. La barre du JavaScript est la plus longue, comme dans la cascade ci-dessus.
Étape 12, l’exécution de l’équipe du cours avec Slow 4G et un processeur ralenti de 4× :
1074.8999999999069Votre nombre sera différent. C’est un temps en millisecondes depuis le début du chargement de la page.
Étape 13, sur le portable de l’équipe du cours, après avoir tapé les 21 caractères « parcel arrived broken » (colis arrivé endommagé) dans chaque version :
Rows drawn: 1050 · React updates: 21 · time in React: 5.2 ms (state too high)Rows drawn: 0 · React updates: 21 · time in React: 1.4 ms (rows in memo)Rows drawn: 0 · React updates: 21 · time in React: 0.3 ms (state moved down)Une mise à jour React par touche; avec l’état trop haut, 50 lignes à chaque fois (21 × 50 = 1 050). Les temps proviennent d’une seule exécution pendant la prise de captures d’écran. Ils diffèrent donc des médianes du tableau du haut. Les comptes ne changent pas d’une exécution à l’autre.
Étape 14 :
First text after 1317.4 ms; finished after 1500.5 ms. 30 pieces, 30 React updates, 0.0 ms in React.First text after 1316.6 ms; finished after 1500.8 ms. 30 pieces, 11 React updates, 0.1 ms in React.La première ligne est « For every piece » (pour chaque fragment), la deuxième « Once per frame » (une fois par image).
À vous de jouer : le même chargement sans le téléphone
Section intitulée « À vous de jouer : le même chargement sans le téléphone »Faites d’abord une prédiction. Sans limitation, sur le réseau habituel de votre ordinateur, les premières lignes arriveront-elles 2 fois, 5 fois ou 10 fois plus vite? Quelle barre de la cascade raccourcit le plus? Réglez le réseau et le processeur sur No throttling, puis rechargez trois fois. Lisez le repère dans la Console à chaque fois.
Afficher la réponse
Sur le portable de l’équipe du cours, sans limitation, les premières lignes sont apparues après 97,4 ms. C’est la médiane de 5 exécutions, allant de 91,1 à 98 ms. Avec le profil simulant un téléphone, elles sont apparues après 1 073,6 ms. Le chargement simulant un téléphone est donc environ 11 fois plus lent.
La barre du JavaScript raccourcit le plus. Sans limitation, index.js est arrivé environ 11 ms après le début du chargement, plutôt que 751 ms. Il passait en effet par une connexion locale. Le temps restant correspond surtout au travail du navigateur et à la réponse de l’API. Voilà pourquoi une mesure sur votre portable renseigne peu sur le téléphone d’Omar. Précisez toujours les conditions dans lesquelles vous avez mesuré un nombre.
Erreur courante
Mesurer le serveur de développement
Symptôme : Teodor mesure avec npm run dev, le serveur que Vite utilise pendant que vous écrivez du code. Dans le panneau Network, le premier chargement du bureau fait maintenant 48 requêtes plutôt que 4. Ces 4 requêtes étaient la page, un fichier JavaScript, un fichier CSS et l’API. Sur le portable de l’équipe du cours, sans limitation, les premières lignes sont apparues après 153,1 ms. C’est la médiane de 5 exécutions, après une première visite. La version de production a pris 97,4 ms. Teodor rapporte : « Le bureau prend 150 ms même sur un portable, donc React doit être lent. »
Cause : le serveur de développement envoie chaque fichier source comme un module distinct, sans les regrouper. La page fait donc beaucoup de petites requêtes. Il utilise aussi la version de développement de React, qui fait des vérifications supplémentaires et qui est plus lente. Ces nombres décrivent l’outil avec lequel vous écrivez du code, pas le bureau que les agents utilisent.
Solution : mesurez toujours une version de production : npm run build, puis npm run preview. Pour le React Profiler (outil de profilage de React), utilisez npm run build:profile. Notez votre méthode de mesure : la version, la limitation et le nombre d’exécutions.
Conséquence pour le travail en IA : une interface de fonctions d’IA semble souvent lente pendant son développement. La réponse du modèle est lente elle aussi. Si vous mesurez la mauvaise version, vous pouvez passer des jours sur la mauvaise partie. Pendant ce temps, la véritable attente reste la même : le modèle ou le téléchargement sur un téléphone.
Quoi mesurer, quand et à quel coût
Section intitulée « Quoi mesurer, quand et à quel coût »| La question | L’outil | Quoi lire |
|---|---|---|
| Que télécharge le navigateur? | npm run size, le panneau Network |
La taille sur le réseau (gzip) de chaque fichier |
| Quand l’agent voit-il du contenu utile? | Un repère comme tickets:first-rows, lu dans la Console ou par un script |
Le temps du repère, dans des conditions précisées |
| Le navigateur est-il occupé? | Le panneau Performance | Les longs blocs de script, de mise en page ou de dessin |
| React dessine-t-il trop? | Le React Profiler, les laboratoires, une version de profilage | Les commits (mises à jour validées) et les composants dessinés |
| L’API est-elle lente? | Le panneau Network : les temps de la requête | L’attente du premier octet de la réponse |
Mesurer a aussi un coût. Les temps changent d’une exécution à l’autre. L’équipe du cours a donc fait chaque mesure 5 fois et rapporte la médiane, la valeur du milieu. Les autres programmes sur l’ordinateur changent les nombres. Les nombres de l’équipe du cours proviennent d’un portable où d’autres tâches étaient en cours. Les vôtres seront différents, mais les formes restent les mêmes. Un portable qui simule un téléphone n’est pas un vrai téléphone. C’est une façon équitable de comparer deux versions, pas une promesse concernant l’appareil d’Omar. Les équipes qui veulent connaître l’expérience réelle des utilisateurs recueillent les mêmes repères dans de vrais navigateurs. Elles les envoient ensuite à un serveur. Cette pratique s’appelle le real-user monitoring (suivi des utilisateurs réels), et elle dépasse le cadre de ce cours.
La règle de ce module est simple : mesurez, changez une seule chose, puis mesurez de nouveau de la même façon.
Vérification des connaissances
Section intitulée « Vérification des connaissances »Vérifiez votre compréhension
Tomás veut envelopper chaque composant dans memo, parce que le bureau semble lent sur le téléphone d'Omar. Que mesurez-vous avant de lui répondre, et qu'ont montré les mesures de cette leçon?
Afficher la réponse
Mesurez d’abord ce qui cause l’attente, dans des conditions simulant un téléphone. Utilisez une version de production, Slow 4G et un processeur 4× plus lent, avec le repère des premières lignes et la cascade. La cascade a montré que le téléchargement du JavaScript représente la plus grande partie de l’attente sur un téléphone. memo n’y change rien. Le laboratoire de rendu répété a montré que memo économisait 1,7 ms pour 20 frappes au clavier. Personne ne peut sentir cette différence. Déplacer l’état de la note plus bas a supprimé les mêmes dessins sans memo.
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 : FCP indique 900 ms et le repère des premières lignes indique 1 150 ms. Qu'a vu l'agent entre ces deux moments, et quel nombre rapportez-vous à Omar?
Afficher la réponse
À FCP, le navigateur a dessiné le premier texte : le titre, les filtres et « Loading tickets… » (chargement des billets…). Les lignes sont arrivées 250 ms plus tard, après la réponse de l’API et leur dessin par React. Rapportez le repère des premières lignes, car c’est le moment où l’agent peut travailler. FCP indique seulement que quelque chose apparaît à l’écran.
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
Votre rapport de taille indique 84,6 KB pour index.js et Vite indique 87,72 kB. Un collègue dit qu'un outil se trompe. Que répondez-vous?
Afficher la réponse
Les deux ont raison; ils comptent différemment. Vite utilise 1 kB = 1 000 octets. Le rapport de taille utilise 1 KB = 1 024 octets et le réglage de compression maximal de gzip. Comparez seulement les tailles provenant du même outil, exécuté de la même façon.
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
- Un délai visible pour l’utilisateur comprend trois types d’attente : le téléchargement, le travail dans le navigateur et l’attente de l’API. Trouvez le plus important avant de changer le code.
- Le repère propre au bureau,
tickets:first-rows, indique quand un agent peut travailler. FCP et LCP indiquent seulement que quelque chose a été dessiné. - Avec un profil simulant un téléphone, le téléchargement du seul fichier JavaScript de 87,7 ko dominait le premier chargement.
react-domreprésente à lui seul 64,1 ko de ce fichier. memoa économisé 1,7 ms pour 20 frappes au clavier; déplacer l’état plus bas a fait pareil sansmemo. Dessiner un brouillon diffusé en continu à chaque fragment a coûté à React moins de 0,01 ms.- Mesurez une version de production (ou la version de profilage pour les nombres de React), jamais le serveur de développement. Notez les conditions et prenez la médiane de plusieurs exécutions.
Ensuite, vous réduisez le premier téléchargement et le coût du dessin de la longue liste. Vous mesurez chaque changement de la même façon.
Leçon suivante : Charger moins de travail