Points clés
Décrire l’interface à partir des données et laisser React réconcilier le DOM
Considérez l’interface comme une description. La promesse fondamentale de React est que les développeurs décrivent l’apparence que devrait avoir l’interface en fonction des données actuelles, tandis que React se charge de créer et de mettre à jour les éléments du navigateur. Un élément React est une instruction, pas le nœud DOM lui-même. ReactDOM transforme ces descriptions en contenu visible et ne met à jour que ce qui a changé.
Commencez par un arbre. Le livre construit une interface de recettes à partir d’un menu, de recettes individuelles, d’ingrédients et d’instructions. Chaque composant décrit une partie de l’écran et, ensemble, ils forment un arbre de composants. Lorsque les données des recettes changent, l’arbre peut être rendu à nouveau pour refléter le nouveau contenu. Cette approche évite d’avoir à créer, ajouter et remplacer manuellement des nœuds DOM dans tout le code de l’application.
Ce qui est utile ici, c’est la distinction entre le résultat souhaité et le travail nécessaire pour le produire. Cette séparation facilite le raisonnement sur les changements d’interface : un composant de recette peut se concentrer sur la recette plutôt que sur la gestion du DOM. Ce modèle ne supprime pas complètement le travail impératif. Les appels réseau, les API du navigateur et les abonnements aux événements doivent toujours être gérés avec soin. L’intérêt de React est que ces effets peuvent rester en périphérie, tandis que la majeure partie de la logique de l’interface demeure une description des données.
Décomposer l’interface en composants réutilisables, puis assembler les éléments
Utilisez JSX pour structurer le code de façon lisible. JSX permet aux développeurs d’écrire, au sein de JavaScript, une syntaxe ressemblant à des balises pour décrire des éléments React. Cela ressemble au HTML, mais les navigateurs ne le comprennent pas directement: une étape de compilation le transforme donc en appels JavaScript. Dans l’application de recettes du livre, un Menu affiche plusieurs composants Recipe, et chaque Recipe délègue les listes d’ingrédients et les étapes de préparation à des composants plus petits.
Préparez le code pour sa mise en production. Babel transforme JSX et les syntaxes JavaScript plus récentes. Webpack suit les imports pour construire un graphe de dépendances, puis regroupe le projet dans des bundles destinés au navigateur. Découper le code en modules aide les développeurs à travailler sur des éléments ciblés et à les tester, même si la compilation de production peut ensuite les réunir. Create React App est présenté comme un moyen d’automatiser une grande partie de cette configuration.
Les limites entre composants sont surtout utiles lorsqu’elles clarifient les responsabilités, et pas simplement lorsqu’elles permettent de réduire la taille des fichiers. Un affichage d’ingrédients peut être réutilisé parce que ses entrées et son rôle sont clairs ; un fragment de balisage sans fonction autonome ne mérite pas forcément son propre composant. Le tour d’horizon des outils de compilation proposé dans le livre souligne aussi une distinction importante : le code source modulaire est organisé pour les développeurs, tandis que le regroupement du code est pensé pour sa livraison. Ce sont des objectifs complémentaires, et non contradictoires.
Garder les transformations pures pour rendre les mises à jour prévisibles, réutilisables et testables
Évitez de modifier les données partagées. La programmation fonctionnelle en JavaScript traite les fonctions comme des valeurs et privilégie les petites opérations qui transforment des entrées en sorties. Une fonction pure renvoie un résultat fondé sur ses arguments, sans les modifier ni provoquer d’effets sans rapport. Pour mettre à jour une note de couleur, par exemple, créez un nouvel objet couleur plutôt que de modifier celui qui existe déjà. Pour ajouter un élément, créez un nouveau tableau au lieu d’insérer l’élément dans le tableau d’origine.
Transformez, puis composez. Le livre met en avant `map` pour produire un tableau transformé, `filter` pour sélectionner des éléments et `reduce` pour combiner plusieurs valeurs en un seul résultat. Il est ensuite possible de composer de petites fonctions pour former un processus plus vaste. L’exemple de l’horloge décompose le formatage et la conversion de l’heure en étapes distinctes, au lieu de tout dissimuler dans une longue procédure.
Ce style réduit le nombre d’endroits où une modification peut se dissimuler. Si une entrée reste intacte, un test peut la fournir à nouveau et s’attendre au même résultat, ce qui facilite l’isolement des erreurs. Cette approche est particulièrement utile lorsque plusieurs composants partagent des données. Elle a toutefois une limite pratique : la copie des données a un coût, et les copies superficielles n’empêchent pas la modification des objets imbriqués. Le principe n’est pas de tout copier aveuglément, mais de rendre les changements d’état explicites et observables.
Conserver les données changeantes dans l’état, les transmettre vers le bas et faire remonter les événements
Attribuez à l’état un emplacement clairement défini. Les props transmettent des données d’un parent à ses enfants; l’état contient les valeurs susceptibles de changer et de déclencher un nouveau rendu. Dans Color Organizer, l’application stocke la liste des couleurs, puis transmet chaque couleur aux composants qui l’affichent. Un clic sur une étoile ou sur un bouton de suppression déclenche un événement transmis par un rappel, afin que le composant qui détient l’état puisse effectuer la mise à jour.
Limitez les transmissions inutiles. Faire transiter des données par de nombreux composants qui ne les utilisent pas peut rendre un grand arbre difficile à gérer. React Context permet à un fournisseur de mettre des valeurs à la disposition des descendants qui en ont besoin. Le fournisseur de couleurs du livre fournit les couleurs et des opérations ciblées, comme les ajouter, les noter et les supprimer. Les composants consommateurs accèdent à ces opérations par l’intermédiaire d’un Hook personnalisé, plutôt que de manipuler directement l’ensemble du tableau d’état.
Cette architecture rend la propriété des données lisible : le composant qui détient une valeur décide de la façon dont elle change, tandis que les composants d’affichage signalent les intentions de l’utilisateur. Cela rappelle une séparation utile, dans les systèmes de plus grande envergure, entre la propriété des données et leur présentation. Context réduit les transmissions répétitives de props, mais peut aussi rendre les dépendances d’un composant moins visibles à l’endroit où il est appelé. Une API Context ciblée, qui propose des actions nommées plutôt qu’un simple mutateur d’état, conserve cette commodité tout en limitant les couplages accidentels.
Utiliser les Hooks pour associer état et effets sans encombrer l’interface de mécanismes
Reliez la logique réutilisable. Les Hooks permettent aux composants fonctionnels d’utiliser des fonctionnalités de React, comme l’état, le contexte et les références. `useState` fournit une valeur actuelle et un mutateur; modifier cette valeur déclenche un rendu. Un Hook personnalisé peut regrouper un comportement récurrent, comme le fait `useInput` pour les champs de formulaire contrôlés: il renvoie la valeur du champ, son gestionnaire de changement et une fonction de réinitialisation.
Gérez les effets avec rigueur. `useEffect` exécute du travail après le rendu, comme enregistrer des données, s’abonner à des mises à jour ou demander des informations. Son tableau de dépendances précise quelles valeurs doivent déclencher l’effet, et une fonction de nettoyage renvoyée par l’effet peut annuler les abonnements lorsqu’un composant est retiré. Les Hooks doivent être appelés au niveau supérieur et toujours dans le même ordre. Le livre conseille également d’utiliser les outils de mémoïsation avec discernement, après avoir mesuré un véritable problème de performances.
Les Hooks facilitent le partage de comportements avec état sans obliger les composants à adopter une structure fondée sur les classes. Cette souplesse exige toutefois de la rigueur : les tableaux de dépendances déclarent ce dont dépend un effet ; ils ne servent pas simplement à empêcher la répétition du travail. Une dépendance manquante peut laisser un effet utiliser des données périmées, tandis que des dépendances superflues peuvent entraîner des répétitions. Considérer les effets comme un mécanisme de synchronisation avec le monde extérieur, plutôt que comme un emplacement général pour la logique, permet de garder ce modèle compréhensible.
Modéliser chaque requête comme étant en attente, réussie ou échouée avant d’en afficher le résultat
Rendez l’attente visible. Une requête réseau prend du temps et peut échouer; un composant piloté par les données a donc besoin de davantage qu’un simple affichage en cas de succès. Le livre représente les requêtes selon trois états: en attente, réussie et échouée. Son Hook `useFetch` rassemble l’état de chargement, les données renvoyées et les erreurs; un composant Fetch peut alors choisir d’afficher un message de chargement, une erreur ou le résultat obtenu.
Tenez compte de l’ordre des requêtes. Dans l’exemple GitHub, les informations sur l’utilisateur, ses dépôts et le fichier README d’un dépôt nécessitent plusieurs requêtes. Des composants imbriqués peuvent créer une cascade où chaque requête attend le résultat de la précédente. Lorsque les requêtes ne dépendent pas les unes des autres, afficher leurs composants côte à côte permet de les lancer en parallèle. Des tests effectués avec un réseau bridé aident à détecter les problèmes liés au chargement lent et au démontage des composants.
Intégrer la latence à l’interface relève autant d’une décision de conception produit que d’une décision de programmation. Un état de chargement clair évite que les utilisateurs prennent un délai pour une page cassée, tandis qu’un état d’erreur explicite donne à l’application la possibilité de récupérer. L’exemple de la cascade fournit aussi un bon moyen d’évaluer les dépendances : si une requête a réellement besoin de la réponse d’une autre, il faut les séquencer ; sinon, les exécuter à la suite ajoute un délai évitable. Le parallélisme doit découler des dépendances entre les données et non être appliqué mécaniquement.
Fenêtrer les longues listes pour que React affiche les lignes visibles, et non des milliers d’autres
Affichez une fenêtre mobile. Une liste virtualisée conserve l’ensemble des données à disposition, mais ne monte que les lignes situées près de la partie visible de l’écran. À mesure que l’utilisateur fait défiler la page, les lignes qui sortent de la fenêtre sont supprimées et les suivantes sont rendues. On évite ainsi de demander au navigateur de créer et de maintenir un arbre DOM gigantesque, alors que l’utilisateur ne peut en voir qu’une petite partie à la fois.
Mesurez la différence. Le livre crée 5 000 faux utilisateurs. Dans son exemple, le rendu de toutes les lignes prenait 52 millisecondes, tandis que `react-window`, en n’en affichant qu’un nombre limité, ramenait le rendu initial à 2,6 millisecondes. Les chiffres exacts dépendent de la configuration, mais la leçon est concrète: pour les grandes listes, réduire la quantité d’interface rendue peut compter davantage que d’optimiser chaque ligne.
La virtualisation illustre bien une optimisation de la forme du travail plutôt qu’une micro-optimisation de sa mise en œuvre. Un utilisateur ne peut pas examiner des milliers de lignes en même temps ; afficher toutes les lignes d’emblée consomme donc des ressources pour du contenu invisible. En contrepartie, cette technique ajoute de la complexité autour du dimensionnement des lignes, du défilement et de l’accessibilité. Pour les listes courtes, un rendu ordinaire est souvent plus simple et suffisant ; la virtualisation se justifie lorsque le volume de données ou une réactivité mesurée rend le coût perceptible.
Attribuer une URL à chaque écran pour que les liens, les marque-pages et les boutons de retour fonctionnent
Rendez la navigation accessible par une adresse. Dans une application monopage, JavaScript modifie l’interface sans charger un document distinct pour chaque vue. Un routeur associe les URL aux composants qui doivent s’afficher et rétablit ainsi les comportements familiers du navigateur. Le livre présente des routes pour l’accueil, la page À propos, les événements, les produits, le contact et une page introuvable, ainsi que des liens de navigation.
Faites porter le contexte par les URL. Les routes imbriquées peuvent partager une mise en page parente tout en affichant différents contenus enfants. Les paramètres de route peuvent identifier des données, par exemple au moyen d’un identifiant de couleur, afin qu’une couleur particulière puisse être ouverte, ajoutée aux marque-pages ou partagée. Les exemples utilisent les composants de route et les Hooks de React Router pour lire les détails de l’emplacement et naviguer. Le routage ne sert donc pas seulement à afficher un menu: il rend l’état de l’interface accessible en dehors du rendu actuel.
Une URL est un contrat compact entre une application et ses utilisateurs. Elle rend une vue accessible après un rechargement, dans l’historique du navigateur et par le partage, au lieu de l’enfermer dans une suite de clics. Cependant, tous les états temporaires de l’interface n’ont pas leur place dans la barre d’adresse. Une couleur sélectionnée ou un résultat de recherche peut justifier une route, puisqu’il s’agit d’un contenu significatif ; un état de survol éphémère, en général, non. Il faut se demander si une personne pourrait raisonnablement vouloir retrouver ou partager cet état.
Tester ce que les utilisateurs peuvent voir et laisser les outils statiques détecter les erreurs en amont
Vérifiez le comportement, pas seulement la syntaxe. Jest exécute les tests, tandis que JSDOM fournit un document simulé pour tester les composants. React Testing Library aide à rechercher les éléments rendus à partir de leur texte ou de leurs libellés, et à déclencher des événements. Le livre teste une case à cocher en recherchant son libellé, en cliquant dessus, puis en vérifiant que sa valeur change. Cette méthode vérifie le comportement au moyen de l’interface plutôt que d’inspecter les détails internes de l’implémentation.
Mettez en place une boucle de rétroaction. Le développement piloté par les tests commence par un test en échec, ajoute le plus petit changement permettant de le faire réussir, puis procède à une refactorisation. ESLint détecte les problèmes de qualité du code, Prettier s’occupe du formatage, et PropTypes, Flow ou TypeScript peuvent repérer les incompatibilités de types de données. Les rapports de couverture indiquent quel code a été exécuté pendant les tests, mais un pourcentage élevé ne prouve pas, à lui seul, que les comportements importants sont bien testés.
Un test qui suit le parcours de l’utilisateur dans l’interface est moins fragile qu’un test étroitement lié à des détails d’implémentation privés. Il devient aussi une description utile du comportement attendu. Les vérifications statiques complètent ces tests en détectant d’autres catégories de problèmes avant l’exécution. Aucun outil ne remplace le jugement : une suite de tests réussie peut tout de même omettre un cas d’échec essentiel, et la couverture peut récompenser l’exécution du code sans vérifier des résultats significatifs. Le processus le plus solide associe des indicateurs automatisés à des choix réfléchis concernant les risques.
Choisir les outils de rendu et de données en fonction du véritable goulot d’étranglement, pas de l’engouement
Choisissez quand le travail s’effectue. Le rendu côté client construit l’interface dans le navigateur. Le rendu côté serveur envoie le HTML initial depuis un serveur, puis le client peut le réhydrater avec JavaScript. Le prérendu crée le HTML avant la requête de l’utilisateur. Le livre présente aussi le fractionnement du code, qui retarde le chargement du code d’un composant jusqu’à ce qu’il soit nécessaire, ainsi que Suspense, qui affiche un contenu de remplacement pendant ce chargement.
Contenez les erreurs et la complexité. Les frontières d’erreur peuvent remplacer une partie défaillante de l’interface par un contenu de remplacement, plutôt que de laisser une seule erreur vider toute l’application. Next.js et Gatsby sont présentés comme des outils qui regroupent des flux de travail de routage, de rendu ou de génération de sites statiques. Les auteurs précisent que les modèles de données Suspense de cette édition sont expérimentaux et susceptibles d’évoluer. Chaque technique répond à des problèmes particuliers, et non à ceux de toutes les applications.
La stratégie de rendu détermine où se situent le calcul, l’attente et la complexité. Le HTML rendu côté serveur peut rendre le contenu initial disponible plus rapidement, tandis que le rendu côté client peut être plus simple pour des vues très interactives. Le fractionnement du code peut réduire les téléchargements initiaux, mais il introduit des états de chargement et d’échec qu’il faut concevoir. La mise en garde du livre concernant le caractère expérimental de Suspense reste particulièrement pertinente : les idées architecturales peuvent survivre à une API particulière ; il est donc plus sûr de comprendre le problème résolu que de considérer un exemple d’implémentation comme définitif.
Analyse
Learning React est à la fois une introduction à la programmation et une visite guidée d’un écosystème en évolution. Son fil conducteur le plus fort n’est ni JSX ni un Hook particulier. C’est le passage d’un contrôle manuel du navigateur à la description d’une interface sous forme de composants structurés par les données, puis à l’explicitation des changements au moyen de l’état et de transformations prévisibles. Cette idée relie le chapitre du livre consacré au JavaScript fonctionnel à son traitement des arbres de composants, des formulaires, des requêtes réseau, du routage et des tests.
La progression pédagogique est une force, car elle fournit aux lecteurs un modèle mental avant d’ajouter l’infrastructure. La syntaxe JavaScript et les concepts fonctionnels préparent le lecteur à comprendre les composants; le projet Color Organizer rend ensuite concrètes la propriété de l’état et la circulation des événements. L’exemple GitHub qui suit élargit ces mêmes idées aux données asynchrones, tandis que la virtualisation des listes, les tests et les stratégies de rendu montrent qu’une interface pose aussi des problèmes de performance et de fiabilité.
Le livre est le plus convaincant lorsqu’il décrit des compromis plutôt que de promouvoir une recette universelle. Context peut réduire les transmissions fastidieuses de props, mais rendre les dépendances moins visibles. La mémoïsation peut éviter du travail, mais ajouter de la complexité. Le rendu côté serveur peut améliorer l’affichage initial, mais exige davantage d’infrastructure. Ce sont des choix architecturaux dont la pertinence dépend de l’échelle de l’application, de ses utilisateurs et de ses goulots d’étranglement.
Sa principale limite tient au temps qui passe. Cette édition date de 2020 et présente des outils et des API en évolution, notamment des exemples expérimentaux de Suspense et une configuration de React Router alors actuelle. Les lecteurs devraient considérer les exemples de code comme des leçons de concepts, et non comme des instructions de configuration nécessairement à jour. L’enseignement durable réside dans le raisonnement qui les sous-tend: rendre le flux des données visible, isoler les effets secondaires, tester les comportements observables et mesurer avant d’optimiser. Le livre offre aux débutants une carte cohérente; ses exemples montrent aussi aux développeurs expérimentés comment la conception de React privilégie des descriptions composables plutôt que des commandes DOM dispersées.
Résumé des avis
Learning React reçoit des avis majoritairement positifs, avec une note moyenne de 4,06 sur 5. Les lecteurs apprécient sa présentation complète des concepts de React, notamment la programmation fonctionnelle, les Hooks et Redux. Le livre est salué pour la clarté de ses explications et ses exemples pratiques. Parmi les critiques figurent des informations dépassées, des erreurs de code et des exemples difficiles à suivre. Plusieurs personnes le recommandent aux débutants, tandis que d’autres estiment qu’il convient davantage à ceux qui ont déjà une certaine expérience de React. Dans l’ensemble, il est considéré comme une bonne introduction à React, même si certains préfèrent consulter la documentation officielle pour obtenir des informations à jour.
Les lecteurs ont aussi lu
Glossaire
JSX
Syntaxe de balises pour ReactUne extension de JavaScript qui permet aux développeurs de décrire des éléments React à l’aide d’une syntaxe semblable à XML ou HTML. Les navigateurs ne comprennent pas directement JSX : un outil de compilation comme Babel le transforme donc en appels JavaScript qui créent des éléments React. Des expressions JavaScript peuvent être intégrées à JSX pour fournir des valeurs dynamiques.
élément React
Description d’un nœud d’interfaceUne description JavaScript de ce que React doit afficher, comprenant un type d’élément, des propriétés et des enfants. Un élément React est distinct du nœud DOM du navigateur qu’il décrit. React utilise ces descriptions pour construire et mettre à jour l’interface visible.
arbre de composants
Structure imbriquée de l’interfaceUne hiérarchie de composants et d’éléments React, qui commence par une racine et se ramifie en composants enfants. Les données peuvent circuler dans cette structure à l’aide de props, tandis que le rendu des composants transforme leurs descriptions en interface utilisateur. L’arbre permet aussi de diviser une interface en parties réutilisables.
Hooks
Fonctionnalités React réutilisablesDes fonctions qui permettent aux composants React d’utiliser des fonctionnalités telles que l’état, les effets, les références et le contexte. Les Hooks intégrés comprennent useState, useEffect et useContext ; les développeurs peuvent combiner des Hooks pour créer des Hooks personnalisés et partager une logique avec état. Les Hooks doivent être appelés au niveau supérieur des composants ou d’autres Hooks, dans un ordre constant.
composant contrôlé
Champ de formulaire géré par ReactUn élément de formulaire dont la valeur affichée est fournie par l’état React. Le gestionnaire de changement d’un champ met à jour cet état, puis le rendu suivant transmet la valeur mise à jour à l’élément. Les valeurs du formulaire sont ainsi explicites dans le composant, ce qui peut simplifier la validation, même si la saisie fréquente entraîne des rendus répétés.
Context
Valeurs partagées avec les descendantsUn mécanisme React qui rend des valeurs accessibles aux composants situés sous un fournisseur, sans les transmettre comme props à chaque composant intermédiaire. Un fournisseur fournit les valeurs, et les descendants peuvent les utiliser. Le livre recommande d’exposer des opérations ciblées par le biais du contexte plutôt que de donner à chaque consommateur un accès sans restriction aux fonctions de mise à jour de l’état.
render props
Comportement de rendu transmis par des propsUn modèle de composant dans lequel une prop fournit un élément ou une fonction qui renvoie un élément. Une render prop fonctionnelle peut recevoir des données : le composant peut ainsi déléguer les décisions sur ce qu’il faut afficher, tout en conservant des mécanismes réutilisables, comme parcourir une liste ou afficher un message lorsque celle-ci est vide.
virtualisation
Ne rendre que les éléments proches dans une listeUne technique de rendu de listes qui conserve un grand jeu de données à disposition, mais ne monte que les éléments visibles ou proches de la zone visible de l’écran. À mesure que l’utilisateur fait défiler la page, la fenêtre des éléments rendus se déplace. Des bibliothèques telles que react-window fournissent cette fonctionnalité et réduisent la quantité d’interface que le navigateur doit rendre à la fois.
Fiber
Unités de travail de renduL’architecture de réconciliation réécrite de React, conçue pour diviser les mises à jour du rendu en unités de travail plus petites. Chaque unité suit ce que React traite et où il en est dans une mise à jour. Cette structure permet à React de faire une pause entre les unités et de laisser du temps au thread principal pour d’autres tâches importantes.
Suspense
Contenu de remplacement pendant une opération en attenteUn modèle de composant React qui affiche un contenu de remplacement pendant qu’une opération prise en charge, comme le chargement d’un composant importé de façon différée, est en attente. Dans l’édition du livre, les usages liés au chargement des données sont présentés comme expérimentaux et susceptibles de changer. Suspense gère les états d’attente, tandis que les limites d’erreur gèrent les échecs de rendu.
réhydratation
Associer un comportement client au HTMLProcessus qui consiste à charger JavaScript dans le navigateur afin qu’une application React côté client puisse prendre le relais du HTML rendu côté serveur. Le navigateur peut afficher le balisage initial avant que le code interactif soit prêt ; React associe ensuite le comportement à l’interface déjà rendue.
application isomorphe
Application rendue sur plusieurs plateformesUne application capable d’effectuer son rendu sur plusieurs plateformes, par exemple un serveur et un navigateur. Le livre la distingue du code universel, qui désigne le même code exact pouvant s’exécuter dans plusieurs environnements. Une application isomorphe peut utiliser du code propre à chaque environnement tout en présentant la même interface sur différentes plateformes.
Télécharger le PDF
Télécharger l'EPUB
.epub est idéal pour lire des livres numériques sur téléphone, tablette ou liseuse.