Rendu et effets
- Leçon 7
- 80 min
- Module 2 : Composants et structure de l'application
Où nous en sommes
Dans la leçon précédente, nous avons trié le code du bureau par responsabilité, et les erreurs arrivent maintenant à l'agent en mots clairs. Mais la liste attend encore un clic sur Search. Quand elle se charge toute seule pendant la saisie, chaque touche pose une nouvelle question à l'API, et une ancienne réponse lente peut remplacer une nouvelle. Dans cette leçon, nous voyons quand React refait le rendu, et comment un effet fait son nettoyage. Pensons d'abord à deux appels à un magasin.
Leçon 7 sur 19 · Architecture frontend et performance des applications d'IARendu et effets
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
Comprenez quand React refait le rendu d’un composant. Calculez ce qui peut l’être au lieu de le stocker. Chargez les données dans un effet avec nettoyage, pour qu’une ancienne réponse lente ne remplace jamais une nouvelle réponse.
Avant de commencerCe qu’il faut savoir et avoir sous la main
Ce que vous devez savoir
- Les composants, les props, l’état et les champs contrôlés, présentés dans Bases de React.
- Les dossiers
api/,ui/,features/etlib/, et le clientapiFetch, présentés dans Organiser par responsabilité. - Les promesses et
then, présentés dans L’essentiel de JavaScript.
Ce qu’il vous faut sur votre ordinateur
- Le bureau obtenu à la fin d’Organiser par responsabilité :
npm testafficheTests 9 passed (9)(9 tests réussis). - L’API simulée en mode normal dans le premier terminal (
npm run api), etnpm run devdans le second. Son terminal affiche une ligne par requête : vous la lirez dans cette leçon.
Testé sur macOS (Apple silicon) avec Node.js 24.18.0 et Chromium. Les durées dépendent de votre ordinateur; c’est l’ordre des événements qui compte.
Un magasin au téléphone
Section intitulée « Un magasin au téléphone »Vous appelez un magasin et demandez : « Avez-vous de la peinture bleue? » Pendant la recherche, vous changez d’avis et rappelez : « Pardon, je voulais dire de la peinture verte. » Deux personnes cherchent maintenant au magasin, une pour chaque appel. La réponse pour le vert arrive d’abord : oui. Puis, une minute plus tard, la première personne rappelle : « Pas de peinture bleue, désolé. » Si vous vous fiez au dernier appel reçu, vous rentrez sans peinture. Un client prudent annule la première question dès qu’il pose la seconde.
Gardez cette image en tête. Dans cette leçon, la liste de billets de soutien pose une nouvelle question à l’API à chaque frappe. Elle doit annuler les anciennes questions.
Quand React refait-il le rendu?
Section intitulée « Quand React refait-il le rendu? »React appelle de nouveau un composant (il refait son rendu) pour deux raisons : son état a changé ou son parent a refait son rendu. Dans le second cas, React appelle aussi chaque enfant, même si ses props restent identiques. Puis React compare le nouveau résultat à la page et modifie seulement ce qui diffère.
Suivez donc une frappe dans le champ de recherche du bureau. TicketFilters appelle onChange, et TicketList définit son état filter. React appelle de nouveau TicketList, puis TicketFilters, puis chacun des 50 composants TicketRow et leurs badges. La page change à un seul endroit : le texte dans le champ.
Est-ce lent? L’équipe du cours l’a mesuré avec React Profiler, un outil présenté dans Mesurer dans le navigateur. Au-dessus de 50 lignes, elle a saisi du texte dans un champ de notes 20 fois, dans trois versions :
| Emplacement du texte de la note | Lignes dont le rendu est refait | Travail de React pour 20 frappes |
|---|---|---|
| État dans le composant qui affiche aussi les lignes | 1 000 | 2,4 ms |
Même emplacement, avec chaque ligne enveloppée dans memo |
0 | 0,7 ms |
État déplacé dans un petit composant NoteBox |
0 | 0,4 ms |
Médianes de 5 essais sur le portable de l’équipe du cours, avec d’autres tâches en cours; vos durées seront différentes.
Le rendu de 1 000 lignes a coûté 2,4 ms au total, soit 0,12 ms par frappe. C’est bien moins que les 16 ms entre deux images à l’écran. Tomás dit : « Enveloppez chaque composant dans memo. » memo demande à React d’ignorer un composant dont les props n’ont pas changé. Cela ajoute du code à chaque composant et a économisé 1,7 ms au total. Déplacer l’état vers un composant enfant a économisé davantage, sans code supplémentaire. La règle : n’optimisez pas le rendu avant d’avoir mesuré un problème. Un nouveau rendu est normal et généralement peu coûteux.
Valeurs dérivées : calculer, sans stocker
Section intitulée « Valeurs dérivées : calculer, sans stocker »La liste affiche Showing 50 tickets. (50 billets affichés). Ce nombre correspond à page.items.length. Vous pourriez le garder dans son propre état et appeler setCount après chaque chargement. Deux valeurs décriraient alors un seul fait. Un jour, un chemin du code met à jour page et oublie count. L’écran affiche alors « 50 billets affichés » au-dessus de 12 lignes.
Une valeur dérivée est calculée à chaque rendu à partir des props et de l’état : page.items.length, ticket.ticket_id === selectedId, reply.length > 600. Elle ne peut jamais être périmée, car elle n’a pas de mémoire. Le coût est un peu de travail à chaque rendu, presque toujours trop faible pour être mesuré. La règle : si vous pouvez la calculer à partir de ce que vous avez, ne la stockez pas.
Le problème : la liste doit se charger seule
Section intitulée « Le problème : la liste doit se charger seule »Grace essaie le bureau. « Pourquoi faut-il appuyer sur Search? Et pourquoi la liste ne suit-elle pas ce que je tape? » La liste doit donc se charger quand elle apparaît, puis chaque fois que le filtre change.
Où placer ce code? Pas dans le corps du composant : React l’appelle à chaque rendu. Une requête à cet endroit définit l’état quand sa réponse arrive. Cela provoque un rendu, qui envoie une requête : une boucle sans fin. Pas non plus dans un gestionnaire d’événement : « la liste est apparue » n’est pas un événement.
L’idée : un effet synchronise quelque chose d’extérieur à React
Section intitulée « L’idée : un effet synchronise quelque chose d’extérieur à React »Un effet est du code que React exécute après le rendu du composant. Il synchronise quelque chose d’extérieur à React avec les props et l’état. Ici, cet élément extérieur est l’API des billets. Vous donnez à React une liste de dépendances : les valeurs utilisées par l’effet. Après chaque rendu, React les compare à celles du rendu précédent. Si l’une a changé, il exécute de nouveau l’effet.
useEffect(() => { listTickets(filter, 50).then(setPage, setError);}, [filter.status, filter.team, filter.q]);Suivez le déroulement avec toutes les valeurs visibles :
| Rendu | Pourquoi React fait le rendu | filter.q |
L’effet s’exécute? | Requête |
|---|---|---|---|---|
| 1 | la liste apparaît | '' |
oui, premier rendu | GET /v1/tickets?limit=50 |
| 2 | la réponse est arrivée : setPage |
'' |
non, rien n’a changé | aucune |
| 3 | vous avez tapé p |
'p' |
oui | …&q=p |
| 4 | vous avez tapé a |
'pa' |
oui | …&q=pa |
À vous d’essayer : un effet sans nettoyage
Section intitulée « À vous d’essayer : un effet sans nettoyage »-
Ouvrez
src/features/tickets/TicketFilters.tsx. Supprimez la ligne<button type="submit">Search</button>, la proponSearchet son appel dansonSubmit. Gardeze.preventDefault(): la touche Entrée ne doit pas recharger la page. Le fichierTicketFilters.tsxde l’instantané fait la même chose en moins de lignes; vous pouvez plutôt le copier. -
Remplacez
src/features/tickets/TicketList.tsxpar la version dans l’encadré ci-dessous. Elle contient l’effet présenté plus haut et aucun bouton Search (rechercher). -
Rechargez http://localhost:5173/. La liste apparaît immédiatement.
-
Regardez le terminal de l’API simulée. La liste a été demandée deux fois :
GET /v1/tickets?limit=50 200 62 msGET /v1/tickets?limit=50 200 62 msC’est l’effet de
StrictMode, dansmain.tsx. En développement seulement, React exécute chaque effet, le nettoie, puis le réexécute immédiatement. Il le fait pour révéler les effets sans nettoyage. Vous comprendrez bientôt pourquoi. -
Cliquez dans Search et tapez
parcelrapidement. Attendez deux secondes.
La liste avec un effet sans nettoyage (un premier essai)
import { useEffect, useState } from 'react';import { listTickets } from '../../api/tickets';import type { TicketFilter, TicketPage } from '../../api/types';import { ErrorMessage } from '../../ui/ErrorMessage';import { TicketFilters } from './TicketFilters';import { TicketRow } from './TicketRow';
export const NO_FILTER: TicketFilter = { status: '', team: '', q: '' };
/** The first 50 tickets that match the filters. A first try: an effect without cleanup. */export function TicketList() { const [filter, setFilter] = useState<TicketFilter>(NO_FILTER); const [page, setPage] = useState<TicketPage | null>(null); const [error, setError] = useState<Error | null>(null);
useEffect(() => { listTickets(filter, 50).then(setPage, setError); }, [filter.status, filter.team, filter.q]);
return ( <section className="list" aria-labelledby="list-heading"> <h2 id="list-heading">Tickets</h2> <TicketFilters value={filter} onChange={setFilter} /> {error && <ErrorMessage error={error} />} {page === null ? ( <p className="muted">Loading tickets…</p> ) : ( <> <p className="muted">{page.items.length === 0 ? 'No ticket matches.' : `Showing ${page.items.length} tickets.`}</p> <ul className="rows"> {page.items.map((t) => ( <li key={t.ticket_id}> <TicketRow ticket={t} /> </li> ))} </ul> </> )} </section> );}
Le champ contient parcel (colis), mais la première ligne est T-80010, le billet le plus récent de tous. Dans l’essai de l’équipe du cours, un seul des 50 objets mentionne un colis; la bonne réponse en contient 24. Le terminal de l’API simulée montre pourquoi. Il affiche chaque réponse au moment de son envoi, dans cet ordre :
GET /v1/tickets?limit=50&q=par 200 219 msGET /v1/tickets?limit=50&q=parc 200 163 msGET /v1/tickets?limit=50&q=pa 200 466 msGET /v1/tickets?limit=50&q=parce 200 161 msGET /v1/tickets?limit=50&q=parcel 200 161 msGET /v1/tickets?limit=50&q=p 200 902 msChaque frappe a envoyé une requête, et chacune a appelé setPage à l’arrivée de sa réponse. La réponse pour p est arrivée en dernier, alors elle est restée à l’écran. Elle est lente parce que la recherche courte p correspond à des milliers de billets. L’API simulée rend cela visible volontairement : sa liste prend 60 ms plus 0,1 ms par billet correspondant (temps serveur simulé).
Description textuelle du graphique
Chaque barre va de l’envoi d’une requête à l’arrivée de sa réponse. « p » : de 0 à 907 ms. « pa » : de 120 à 589 ms. « par » : de 240 à 461. « parc » : de 360 à 528. « parce » : de 480 à 647. « parcel » : de 600 à 767 ms. Donc « p » arrive 140 ms après « parcel » et le remplace. Les durées sont les temps de réponse médians de l’équipe sur l’API simulée, ajoutés au calendrier des frappes.
C’est la course entre réponses périmées : une ancienne réponse arrive après la nouvelle et la remplace. L’équipe du cours a tapé parcel de cette façon 10 fois. L’écran était incorrect 10 fois sur 10, et affichait toujours les résultats pour p. Aucune erreur n’apparaît. L’agent voit une liste qui semble correcte, mais qui correspond à la mauvaise recherche.
La solution : le nettoyage
Section intitulée « La solution : le nettoyage »Un effet peut retourner une fonction : son nettoyage. React l’appelle avant de réexécuter l’effet, et quand le composant quitte l’écran. C’est le moment d’annuler l’ancienne question, comme le client prudent au téléphone.
Le navigateur possède un outil pour cela. Un AbortController crée un signal que vous donnez à fetch. Quand vous appelez controller.abort(), le navigateur ferme la requête, et sa promesse échoue avec une AbortError. Le petit hook (fonction React) du projet, useApi, rassemble ces éléments :
// Our own small data hook: it loads data in an effect, and it cancels the old request when the// inputs change or the component goes away (the cleanup). Without the cleanup, a slow old answer// can arrive after a new one and replace it.import { useEffect, useState, type DependencyList } from 'react';
export type ApiState<T> = | { status: 'loading'; data: null; error: null } | { status: 'success'; data: T; error: null } | { status: 'error'; data: null; error: Error };
export function useApi<T>(load: (signal: AbortSignal) => Promise<T>, deps: DependencyList): ApiState<T> { const [state, setState] = useState<ApiState<T>>({ status: 'loading', data: null, error: null }); useEffect(() => { const controller = new AbortController(); setState({ status: 'loading', data: null, error: null }); load(controller.signal).then( (data) => { if (!controller.signal.aborted) setState({ status: 'success', data, error: null }); }, (error: Error) => { if (!controller.signal.aborted) setState({ status: 'error', data: null, error }); }, ); return () => controller.abort(); // cleanup: the answer of this request is not wanted any more // The caller lists every value that `load` uses in `deps`. A missing value means an old answer. }, deps); return state;}Une fonction dont le nom commence par use et qui appelle des hooks est un hook personnalisé. Elle se trouve dans lib/, car elle ne connaît rien aux billets. Chaque exécution de l’effet possède son propre controller. Suivez les deux premières frappes :
| Moment | Ce qui se passe |
|---|---|
vous tapez p |
exécution 1 de l’effet : contrôleur A, requête q=p avec le signal A |
vous tapez a |
nettoyage de l’exécution 1 : A.abort(); le navigateur ferme q=p · exécution 2 : contrôleur B, requête q=pa |
… parcel |
chaque frappe annule la requête précédente |
q=parcel répond |
B…F sont annulés; seul le dernier contrôleur ne l’est pas, donc sa réponse s’affiche |
La vérification if (!controller.signal.aborted) est une seconde protection. Si une réponse était déjà en route au moment de l’annulation, elle est rejetée. L’équipe du cours a fait 10 essais de chaque version : avec nettoyage, l’écran était incorrect 0 fois. Six requêtes ont été envoyées, et 5 ont été fermées avant la réponse.
Construire : le bureau à la fin du module
Section intitulée « Construire : le bureau à la fin du module »-
Créez
src/lib/useApi.ts(ci-dessus) et ses testssrc/lib/useApi.test.tsx, à partir de l’instantanéend-of-m02. Le second test reproduit la course : il répond àparceld’abord, puis àp, et vérifie queparcelreste. -
Créez
src/router.tsetsrc/router.test.tsà partir de l’instantané. La partie de l’adresse après#désigne la page :#/tickets/T-80008affiche la liste avec un billet ouvert. L’adresse existe hors de React. DoncuseRouteutilise le hookuseSyncExternalStorede React : il lit l’adresse et refait le rendu d’Appquand elle change. La route est dérivée de l’adresse, pas stockée dans l’état. -
Remplacez
src/features/tickets/TicketList.tsx,TicketRow.tsxetTicketList.test.tsxpar les fichiers de l’instantané. La liste utilise maintenantuseApi, et chaque ligne est un lien vers son billet. -
Créez
src/features/tickets/TicketView.tsxà partir de l’instantané (dans l’encadré ci-dessous). Il charge un billet avecuseApiet utilise[ticketId]comme dépendance. -
Remplacez
src/App.tsxpar le fichier de l’instantané : une barre de navigation et la liste à côté du billet désigné par l’adresse. -
Exécutez
npx tsc --noEmit(aucune sortie), puisnpm test. La fin afficheTest Files 6 passed (6)(6 fichiers de tests réussis) etTests 14 passed (14)(14 tests réussis). -
Rechargez le bureau et tapez encore
parcelrapidement. Maintenant, 24 des 50 objets mentionnent un colis. Le terminal de l’API simulée montre une seule requête ayant reçu une réponse,q=parcel. Le navigateur a fermé les cinq autres avant leur réponse. -
Cliquez sur
T-80008. L’adresse devient#/tickets/T-80008, la ligne est marquée et le billet apparaît à droite. Ouvrez http://localhost:5173/#/tickets/T-99999 : la partie droite afficheThere is no ticket T-99999.(il n’y a aucun billet T-99999). -
Exécutez
npm run build. La sortie se termine par un fichier JavaScript de 227,47 ko (gzip : 71,21 ko) et✓ built in(construction terminée en). Copiez aussiREADME.mddepuis l’instantané : il décrit maintenant l’interface React. Votre dossier correspond maintenant à l’instantanéend-of-m02.
La liste et la vue du billet à la fin du module
import { useState } from 'react';import { listTickets } from '../../api/tickets';import type { TicketFilter } from '../../api/types';import { useApi } from '../../lib/useApi';import { ErrorMessage } from '../../ui/ErrorMessage';import { TicketFilters } from './TicketFilters';import { TicketRow } from './TicketRow';
export const NO_FILTER: TicketFilter = { status: '', team: '', q: '' };
/** The first 50 tickets that match the filters. The filters are this component's own state. */export function TicketList({ selectedId }: { selectedId: string | null }) { const [filter, setFilter] = useState<TicketFilter>(NO_FILTER); const tickets = useApi((signal) => listTickets(filter, 50, null, signal), [filter.status, filter.team, filter.q]);
return ( <section className="list" aria-labelledby="list-heading"> <h2 id="list-heading">Tickets</h2> <TicketFilters value={filter} onChange={setFilter} /> {tickets.status === 'loading' && <p className="muted">Loading tickets…</p>} {tickets.status === 'error' && <ErrorMessage error={tickets.error} />} {tickets.status === 'success' && ( <> <p className="muted">{tickets.data.items.length === 0 ? 'No ticket matches.' : `Showing ${tickets.data.items.length} tickets.`}</p> <ul className="rows"> {tickets.data.items.map((t) => ( <li key={t.ticket_id}> <TicketRow ticket={t} selected={t.ticket_id === selectedId} /> </li> ))} </ul> </> )} </section> );}import { getTicket } from '../../api/tickets';import { useApi } from '../../lib/useApi';import { ErrorMessage } from '../../ui/ErrorMessage';import { StatusBadge } from '../../ui/StatusBadge';
/** One ticket: the customer's message and the conversation. */export function TicketView({ ticketId }: { ticketId: string }) { const ticket = useApi((signal) => getTicket(ticketId, signal), [ticketId]);
if (ticket.status === 'loading') return <p className="muted">Loading {ticketId}…</p>; if (ticket.status === 'error') return <ErrorMessage error={ticket.error} />; const t = ticket.data; return ( <article className="ticket" aria-labelledby="ticket-heading"> <header> <p className="muted"> {t.ticket_id} · {t.customer_name} ({t.customer_id}) · {t.team} · priority {t.priority} </p> <h2 id="ticket-heading">{t.subject}</h2> <StatusBadge status={t.status} /> </header> <section aria-label="Conversation"> <div className="message message-customer"> <p className="muted">Customer</p> <p>{t.body || '(no text)'}</p> </div> {t.messages.map((m) => ( <div key={m.message_id} className={`message message-${m.author}`}> <p className="muted">{m.author === 'agent' ? 'Agent' : 'Customer'}</p> <p>{m.body}</p> </div> ))} </section> </article> );}
Qui possède chaque valeur
Section intitulée « Qui possède chaque valeur »Nous pouvons maintenant répondre à la question du module pour l’ensemble du bureau. Chaque valeur pouvant changer a exactement un propriétaire. Tous les autres endroits la reçoivent comme prop ou la calculent.
Description textuelle du diagramme
Deux sources sont hors de React. La barre d’adresse possède la route : App la lit avec useRoute et ne la copie jamais dans l’état. L’API des billets possède les billets : TicketList et TicketView les chargent avec useApi. App transmet selectedId à la liste et ticketId à la vue. TicketList possède une valeur d’état, filter, et la transmet à TicketFilters avec onChange. Chaque TicketRow reçoit un billet et une valeur dérivée selected. NewTicketForm, sur sa propre page, possède les valeurs du formulaire et son état d’envoi. Les leçons suivantes ajoutent MessageForm et DraftPanel sous la vue du billet.
Quand utiliser un effet, et son coût. Utilisez un effet pour synchroniser quelque chose d’extérieur à React : données du filtre actuel, connexion suivant le billet ouvert, minuterie. N’en utilisez pas pour des valeurs dérivées ou une action humaine, comme l’envoi d’un formulaire : cela relève du gestionnaire d’événement. Chaque effet peut contenir des bogues liés au temps : listez toutes ses dépendances et nettoyez ce qu’il démarre. Il manque encore des choses à useApi : revenir à un billet le recharge, et rien n’actualise la liste après une modification. État local et état serveur le remplace par une bibliothèque, TanStack Query. Le laboratoire sur la course y compare les trois approches.
Erreur courante
Une dépendance absente de la liste
Symptôme : Teodor écrit les dépendances de la liste sous la forme [filter.q]. La recherche fonctionne. Mais en choisissant pending (en attente) dans Status (statut), la liste ne change pas. Elle change seulement à la prochaine frappe dans le champ de recherche.
Cause : l’effet utilise filter.status, mais React ne le sait pas. Après le rendu, il compare seulement filter.q, ne voit aucun changement et n’exécute pas l’effet. L’écran affiche encore la réponse à une ancienne question, sans erreur.
Solution : listez chaque valeur des props ou de l’état que l’effet lit : ici, filter.status, filter.team et filter.q. Ne listez pas l’objet filter entier seulement par précaution. React compare les objets par leur identité. Un nouvel objet contenant les mêmes valeurs relance donc l’effet. Le commentaire à la fin de useApi est là pour cette raison.
Conséquence dans le travail en IA : au module 4, un effet suit le flux du brouillon du billet ouvert. Sans ticketId dans ses dépendances, le panneau continuerait d’afficher le brouillon du billet précédent sous le titre du nouveau.
Vérification des connaissances
Section intitulée « Vérification des connaissances »Vérifiez votre compréhension
Prédisez : vous tapez une lettre dans le champ de recherche du bureau terminé. Quels composants React appelle-t-il de nouveau? Combien de requêtes la liste envoie-t-elle?
Afficher la réponse
L’état filter de TicketList change. React appelle donc de nouveau TicketList et tous ses enfants : TicketFilters, 50 composants TicketRow et leurs badges. C’est normal et peu coûteux (environ 0,12 ms par frappe selon les mesures de l’équipe du cours). filter.q a changé, donc l’effet dans useApi s’exécute. Son nettoyage annule la requête en cours, s’il y en a une, et une nouvelle requête est envoyée. React n’appelle pas App ni TicketView : ils sont au-dessus ou à côté de la liste.
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
Expliquez la course entre les réponses périmées dans le bureau, et comment le nettoyage l'empêche.
Afficher la réponse
Chaque frappe lance une requête. La recherche courte p correspond à de nombreux billets de soutien. Sa réponse prend donc environ 900 ms, plus longtemps que les recherches suivantes. Sans nettoyage, chaque réponse appelle setPage à son arrivée. La réponse pour p arrive en dernier. Le champ affiche donc parcel, mais la liste montre les résultats pour p (10 fois sur 10 dans l’essai de l’équipe). Avec le nettoyage, React appelle controller.abort() de l’exécution précédente avant chaque nouvelle exécution. Le navigateur ferme l’ancienne requête, et useApi ignore toute réponse dont le signal est annulé. Seule la recherche la plus récente peut donc définir l’état.
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
Tomás veut stocker le nombre de billets dans un état distinct et envelopper chaque composant dans memo. Que lui dites-vous?
Afficher la réponse
Le nombre est une valeur dérivée : tickets.data.items.length. Calculez-le pendant le rendu; une deuxième copie dans l’état peut différer de la liste. Pour memo, mesurez d’abord. Refaire le rendu de 50 lignes coûtait 0,12 ms par frappe, bien en dessous de ce qu’une personne peut percevoir. Déplacer l’état vers un composant enfant a supprimé les rendus supplémentaires sans nouveau code : 0,4 ms pour 20 frappes, contre 0,7 ms avec memo. Utilisez memo seulement lorsqu’une mesure révèle un composant lent.
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.
Exercice du module : diviser un grand écran d’assistant
Section intitulée « Exercice du module : diviser un grand écran d’assistant »Tomás a créé un premier écran pour le brouillon d’IA dans un seul grand composant, AssistantScreen. Il comprend l’en-tête du billet, le message du client, le brouillon avec Use the draft (utiliser le brouillon), un champ de réponse avec un compteur de caractères et une note. Ses données sont T-80008 et son véritable brouillon enregistré. Placez-le dans src/practice/AssistantScreen.tsx. Affichez-le dans App.tsx à la place de NewTicketForm pendant votre travail.
Le grand composant (départ)
// Module 2 practice: one large screen. Split it into small components.// The ticket and the draft are T-80008 and its recorded AI draft from the mock API's data.import { useState } from 'react';import { StatusBadge } from '../ui/StatusBadge';
const TICKET = { ticket_id: 'T-80008', customer_name: 'Tariq Jensen', subject: 'Hello, where is my order LK-581106?', status: 'open' as const, body: 'Hello, where is my order LK-581106? The confirmation email said the garden shed shipped on Monday, but I have no delivery date yet.',};const DRAFT = { reply: 'I’m sorry you haven’t received a delivery date for your garden shed. Our delivery team can help check the shipment and tracking information for your order.', confidence: 'high', needs_human: false,};const MAX = 600;
export function AssistantScreen() { const [reply, setReply] = useState(''); const [note, setNote] = useState(''); const [sent, setSent] = useState<string | null>(null);
return ( <article className="ticket"> <header> <p className="muted"> {TICKET.ticket_id} · {TICKET.customer_name} </p> <h2>{TICKET.subject}</h2> <StatusBadge status={TICKET.status} /> </header> <div className="message message-customer"> <p className="muted">Customer</p> <p>{TICKET.body}</p> </div> <section className="draft" aria-label="AI draft"> <p className="muted"> AI draft · confidence {DRAFT.confidence} {DRAFT.needs_human ? ' · a person must check it' : ''} </p> <p>{DRAFT.reply}</p> <button type="button" onClick={() => setReply(DRAFT.reply)}> Use the draft </button> </section> <form className="form" onSubmit={(e) => { e.preventDefault(); setSent(reply); setReply(''); }} > <label htmlFor="reply">Reply to the customer</label> <textarea id="reply" rows={4} value={reply} onChange={(e) => setReply(e.target.value)} /> <p className="muted"> {reply.length} of {MAX} characters </p> <button type="submit" disabled={reply.trim() === '' || reply.length > MAX}> Send reply </button> </form> {sent && <p role="status">Sent: {sent}</p>} <label className="form"> Note for the team <input value={note} onChange={(e) => setNote(e.target.value)} /> </label> </article> );}Exercice guidé : la première partie. Extrayez l’en-tête, étape par étape, et vérifiez l’écran après chaque étape.
-
Trouvez les valeurs que l’en-tête lit :
TICKET.ticket_id,TICKET.customer_name,TICKET.subjectetTICKET.status. Elles font toutes partie d’un même objet. Le nouveau composant reçoit donc une seule propriété,ticket. -
Demandez-vous si l’en-tête change un état. Ce n’est pas le cas. Il n’a donc besoin ni d’une propriété de fonction ni d’un état.
-
Écrivez le composant au-dessus de
AssistantScreen, avec le JSX de l’en-tête, et remplacezTICKET.particket.:function TicketHeader({ ticket }: { ticket: typeof TICKET }) {return (<header><p className="muted">{ticket.ticket_id} · {ticket.customer_name}</p><h2>{ticket.subject}</h2><StatusBadge status={ticket.status} /></header>);} -
Dans
AssistantScreen, remplacez tout le bloc<header>…</header>par<TicketHeader ticket={TICKET} />. -
Rechargez la page. L’écran reste identique :
T-80008 · Tariq Jensen, le sujet et l’étiquette Open (ouvert). Exécuteznpx tsc --noEmit: aucune sortie.
Travail autonome. Divisez le reste de AssistantScreen en petits composants : le message du client, la zone du brouillon, le formulaire de réponse et la note. Ensuite, pour chaque valeur qu’une personne peut modifier, notez son unique propriétaire. Posez-vous deux questions pour décider : quels composants lisent la valeur, et lesquels la modifient? Résultat attendu : l’écran garde la même apparence et le même fonctionnement. Use the draft remplit le champ de réponse. Le compteur suit (155 of 600 characters, soit 155 caractères sur 600, pour le brouillon). Send reply (envoyer la réponse) affiche le texte et vide le champ. La note conserve son texte.
Une solution détaillée
function CustomerMessage({ body }: { body: string }) { return ( <div className="message message-customer"> <p className="muted">Customer</p> <p>{body}</p> </div> );}
function DraftBox({ draft, onUse }: { draft: typeof DRAFT; onUse: (text: string) => void }) { return ( <section className="draft" aria-label="AI draft"> <p className="muted"> AI draft · confidence {draft.confidence} {draft.needs_human ? ' · a person must check it' : ''} </p> <p>{draft.reply}</p> <button type="button" onClick={() => onUse(draft.reply)}> Use the draft </button> </section> );}
function ReplyForm({ value, onChange, onSend }: { value: string; onChange: (v: string) => void; onSend: () => void }) { const tooLong = value.length > MAX; // derived from the prop: no state needed return ( <form className="form" onSubmit={(e) => { e.preventDefault(); onSend(); }} > <label htmlFor="reply">Reply to the customer</label> <textarea id="reply" rows={4} value={value} onChange={(e) => onChange(e.target.value)} /> <p className="muted"> {value.length} of {MAX} characters </p> <button type="submit" disabled={value.trim() === '' || tooLong}> Send reply </button> </form> );}
function NoteBox() { const [note, setNote] = useState(''); return ( <label className="form"> Note for the team <input value={note} onChange={(e) => setNote(e.target.value)} /> </label> );}
export function AssistantScreen() { const [reply, setReply] = useState(''); const [sent, setSent] = useState<string | null>(null); return ( <article className="ticket"> <TicketHeader ticket={TICKET} /> <CustomerMessage body={TICKET.body} /> <DraftBox draft={DRAFT} onUse={setReply} /> <ReplyForm value={reply} onChange={setReply} onSend={() => { setSent(reply); setReply(''); }} /> {sent && <p role="status">Sent: {sent}</p>} <NoteBox /> </article> );}| Valeur | Lue par | Modifiée par | Propriétaire unique |
|---|---|---|---|
| le texte de la réponse | ReplyForm |
ReplyForm (saisie), DraftBox (Use the draft), AssistantScreen (après l’envoi) |
état dans AssistantScreen, le parent commun le plus proche |
| la note | NoteBox |
NoteBox |
état dans NoteBox : aucun autre composant n’en a besoin, donc l’état a été déplacé vers l’enfant |
| la dernière réponse envoyée | AssistantScreen |
AssistantScreen |
état dans AssistantScreen |
| le nombre de caractères, « trop long », activation de « Send » (envoyer) | ReplyForm |
personne | valeurs dérivées de la réponse : pas un état |
| le billet et le brouillon | l’en-tête, le message, la zone du brouillon | personne ici | l’API (ici, des constantes); plus tard, le serveur et le flux |
L’état de la note est passé dans un composant enfant. La saisie dans la note ne refait donc plus le rendu du reste de l’écran. L’équipe du cours a vérifié le fichier de départ et cette solution avec les deux mêmes tests Testing Library : les deux réussissent.
Vérification finale : une source de vérité pour chaque valeur modifiable. Tomás change une ligne de ReplyForm dans la solution : const [text, setText] = useState(value);. Le formulaire affiche alors text et appelle à la fois setText et onChange pendant la saisie. Il tape Thanks (merci), l’efface, puis appuie sur Use the draft. Prédisez ce qu’affiche le champ de réponse, expliquez pourquoi et nommez l’unique propriétaire du texte de la réponse.
La réponse
Le champ reste vide, et le compteur reste à 0 of 600 characters (0 caractère sur 600). Les deux tests de l’exercice de l’équipe du cours échouent. Le champ ignore Use the draft et conserve son texte après Send reply. useState(value) copie la propriété une seule fois, au premier rendu, quand sa valeur était ''. Use the draft modifie reply dans AssistantScreen. La nouvelle propriété arrive, mais rien ne la lit. Deux copies d’une même valeur diffèrent, sans erreur. L’unique propriétaire est l’état reply dans AssistantScreen. ReplyForm doit afficher la propriété value et signaler les changements avec onChange. La même règle s’applique à chaque valeur modifiable du bureau : filter dans TicketList, les valeurs dans NewTicketForm, la note dans NoteBox.
Supprimez src/practice/ et remettez NewTicketForm dans App.tsx quand vous avez terminé; l’instantané end-of-m02 ne les contient pas. Pour repartir d’un état propre, téléchargez l’instantané end-of-m02 et exécutez npm install dans ce dossier.
Récapitulatif
Cette leçon
- React refait le rendu d’un composant quand son état change ou quand son parent refait son rendu. C’est normal et généralement peu coûteux : 1 000 rendus de lignes ont pris 2,4 ms. Mesurez avant d’ajouter
memo; déplacer l’état vers un enfant est souvent une meilleure solution. - Une valeur dérivée se calcule pendant le rendu (
items.length,selected,tooLong). Ne stockez jamais une copie de cette valeur dans l’état. - Un effet s’exécute après le rendu pour synchroniser quelque chose à l’extérieur de React. Ses dépendances comprennent chaque valeur qu’il lit; React l’exécute de nouveau quand l’une d’elles change.
- Sans nettoyage, une ancienne réponse lente peut remplacer une nouvelle réponse : 10 recherches sur 10 pour « parcel » affichaient les résultats de « p ». Avec
AbortControllerdans le nettoyage, aucune des 10 recherches ne le faisait, et les anciennes requêtes étaient fermées plus tôt.
Ce module
- Le bureau est un arbre de composants : les propriétés descendent, les événements remontent, et chaque valeur modifiable a un propriétaire unique.
- Le code est organisé par responsabilité :
api/communique avec l’API,ui/contient les éléments réutilisables,features/contient les écrans, etlib/contient les outils généraux commeuseApi. - Le projet correspond maintenant à l’instantané
end-of-m02: 35 vérifications dansnpm test(21 pour l’API simulée et 14 pour l’interface).
Ensuite, vous séparerez les choix de l’agent à l’écran des données stockées par le serveur. Une bibliothèque prendra en charge le chargement, la mise en cache et l’annulation.
Leçon suivante : État local et état serveur