Aller au contenu
English

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.

Lue depuis YouTube. Rien ne se charge depuis YouTube avant que vous appuyiez sur lecture. Confidentialité

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 mainEnviron 80 minutes

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur

  • Le bureau obtenu à la fin d’Organiser par responsabilité : npm test affiche Tests 9 passed (9) (9 tests réussis).
  • L’API simulée en mode normal dans le premier terminal (npm run api), et npm run dev dans 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.

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.

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.

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.

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
  1. Ouvrez src/features/tickets/TicketFilters.tsx. Supprimez la ligne <button type="submit">Search</button>, la prop onSearch et son appel dans onSubmit. Gardez e.preventDefault() : la touche Entrée ne doit pas recharger la page. Le fichier TicketFilters.tsx de l’instantané fait la même chose en moins de lignes; vous pouvez plutôt le copier.

  2. Remplacez src/features/tickets/TicketList.tsx par la version dans l’encadré ci-dessous. Elle contient l’effet présenté plus haut et aucun bouton Search (rechercher).

  3. Rechargez http://localhost:5173/. La liste apparaît immédiatement.

  4. Regardez le terminal de l’API simulée. La liste a été demandée deux fois :

    GET /v1/tickets?limit=50 200 62 ms
    GET /v1/tickets?limit=50 200 62 ms

    C’est l’effet de StrictMode, dans main.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.

  5. Cliquez dans Search et tapez parcel rapidement. Attendez deux secondes.

La liste avec un effet sans nettoyage (un premier essai)
src/features/tickets/TicketList.tsx
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>
);
}
La liste Tickets (billets). Le champ de recherche contient parcel. En dessous : Showing 50 tickets (50 billets affichés). La première ligne est T-80010, Return label for my order LK-300210 (étiquette de retour pour ma commande LK-300210), Test Customer : la même première ligne que sans recherche.
Le champ contient « parcel », mais les lignes répondent à « p ». L’image est en anglais.

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 ms
GET /v1/tickets?limit=50&q=parc 200 163 ms
GET /v1/tickets?limit=50&q=pa 200 466 ms
GET /v1/tickets?limit=50&q=parce 200 161 ms
GET /v1/tickets?limit=50&q=parcel 200 161 ms
GET /v1/tickets?limit=50&q=p 200 902 ms

Chaque 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é).

Six recherches pendant la saisie de « parcel », avec 120 ms entre les frappes. La recherche « p » part en premier, et sa réponse arrive en dernier, après celle de « parcel ».
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.

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 :

src/lib/useApi.ts
// 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.

  1. Créez src/lib/useApi.ts (ci-dessus) et ses tests src/lib/useApi.test.tsx, à partir de l’instantané end-of-m02. Le second test reproduit la course : il répond à parcel d’abord, puis à p, et vérifie que parcel reste.

  2. Créez src/router.ts et src/router.test.ts à partir de l’instantané. La partie de l’adresse après # désigne la page : #/tickets/T-80008 affiche la liste avec un billet ouvert. L’adresse existe hors de React. Donc useRoute utilise le hook useSyncExternalStore de React : il lit l’adresse et refait le rendu d’App quand elle change. La route est dérivée de l’adresse, pas stockée dans l’état.

  3. Remplacez src/features/tickets/TicketList.tsx, TicketRow.tsx et TicketList.test.tsx par les fichiers de l’instantané. La liste utilise maintenant useApi, et chaque ligne est un lien vers son billet.

  4. Créez src/features/tickets/TicketView.tsx à partir de l’instantané (dans l’encadré ci-dessous). Il charge un billet avec useApi et utilise [ticketId] comme dépendance.

  5. Remplacez src/App.tsx par le fichier de l’instantané : une barre de navigation et la liste à côté du billet désigné par l’adresse.

  6. Exécutez npx tsc --noEmit (aucune sortie), puis npm test. La fin affiche Test Files 6 passed (6) (6 fichiers de tests réussis) et Tests 14 passed (14) (14 tests réussis).

  7. Rechargez le bureau et tapez encore parcel rapidement. 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.

  8. 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 affiche There is no ticket T-99999. (il n’y a aucun billet T-99999).

  9. 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 aussi README.md depuis 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
src/features/tickets/TicketList.tsx
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>
);
}
src/features/tickets/TicketView.tsx
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>
);
}
Le bureau avec l'adresse #/tickets/T-80008. À gauche, la liste des billets; la ligne T-80008, Hello, where is my order LK-581106? (bonjour, où est ma commande LK-581106?), Tariq Jensen, shipping (livraison), est mise en évidence. À droite, le billet : T-80008, Tariq Jensen (C-81265), shipping, priorité 2, le titre Hello, where is my order LK-581106?, une étiquette Open (ouvert), et le message du client concernant un abri de jardin sans date de livraison.
Le bureau à la fin du module : l'adresse désigne le billet, la liste le marque et la vue le charge. L’image est en anglais.

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.

L'arbre des composants à la fin du module, avec deux sources hors de React. La barre d'adresse (#/tickets/T-80008) alimente App par useRoute : App lit la route depuis l'adresse. App donne selectedId à TicketList et ticketId à TicketView, et affiche NewTicketForm sur une autre page. TicketList possède l'état filter et récupère les billets de l'API avec useApi; ses enfants sont TicketFilters (props value et onChange) et TicketRow, 50 fois (props ticket et selected). TicketView récupère le billet de l'API des billets avec useApi. NewTicketForm possède values, errors, sending, answer et failure. Encadrés en pointillés sous TicketView : MessageForm, ajouté dans Pagination et formulaires, et DraftPanel, ajouté dans Interfaces en flux continu.
Un propriétaire pour chaque valeur : l'adresse possède la route, l'API possède les billets et deux composants possèdent l'état modifié par l'utilisateur.
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é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.

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.

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.

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)
src/practice/AssistantScreen.tsx
// 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.

  1. Trouvez les valeurs que l’en-tête lit : TICKET.ticket_id, TICKET.customer_name, TICKET.subject et TICKET.status. Elles font toutes partie d’un même objet. Le nouveau composant reçoit donc une seule propriété, ticket.

  2. 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.

  3. Écrivez le composant au-dessus de AssistantScreen, avec le JSX de l’en-tête, et remplacez TICKET. par ticket. :

    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>
    );
    }
  4. Dans AssistantScreen, remplacez tout le bloc <header>…</header> par <TicketHeader ticket={TICKET} />.

  5. Rechargez la page. L’écran reste identique : T-80008 · Tariq Jensen, le sujet et l’étiquette Open (ouvert). Exécutez npx 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
src/practice/AssistantScreen.tsx (the components)
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 AbortController dans 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, et lib/ contient les outils généraux comme useApi.
  • Le projet correspond maintenant à l’instantané end-of-m02 : 35 vérifications dans npm 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