Démarrer l'essai gratuit
Tendances Nouveau Genres Auteurs
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Recherche en cours...
SoBrief
Learning React

Learning React

Créez des interfaces React prévisibles, faciles à tester et rapides, sans devoir deviner ce qui se passe à chaque mise à jour.
par Alex Banks 2017 350 pages
4.07
500+ évaluations
Écouter
Immersif
V2.3
Amazon Kindle Audible
Essayez l'accès complet pendant 3 jours
Débloquez l'écoute et bien plus !
Continuer

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.

Analyse

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.

Analyse

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.

Analyse

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.

Analyse

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.

Analyse

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.

Analyse

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.

Analyse

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.

Analyse

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.

Analyse

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.

Analyse

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é en 30 secondes
Les composants React décrivent l’interface à partir des données actuelles, tandis que React gère les mises à jour du navigateur. Conservez les valeurs changeantes dans l’état, transmettez-les aux composants enfants et faites remonter les actions de l’utilisateur par des fonctions de rappel. Les transformations pures rendent les mises à jour plus faciles à réutiliser et à tester ; les Hooks regroupent l’état et les effets dans une logique réutilisable. Gérez les activités réseau en distinguant le chargement, la réussite et l’échec. Pour 5 000 lignes, le rendu des seuls éléments visibles a fait passer le rendu initial d’un exemple de 52 millisecondes à 2,6. Testez le comportement visible par l’utilisateur et mesurez les performances avant de les optimiser.
Contient des spoilers

Dernière mise à jour:

Signaler un problème

Résumé des avis

4.07 sur 5
Moyenne de 500+ évaluations de Goodreads et Amazon.

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.

Votre note :
4.49
135 évaluations
Envie de lire le livre complet ?

Glossaire

JSX

Syntaxe de balises pour React

Une 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’interface

Une 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’interface

Une 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éutilisables

Des 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 React

Un é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 descendants

Un 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 props

Un 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 liste

Une 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 rendu

L’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 attente

Un 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 HTML

Processus 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 plateformes

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

À propos de l'auteur

Alex Banks est une autrice qui affirme détenir une « ceinture noire en génialité » grâce à ses talents d’écriture. Elle vit dans l’Utah avec sa famille, qui comprend son mari et ses deux fils. Banks partage également son foyer avec une ménagerie variée : un chat, un chien et quatre tortues. Avec humour, elle attribue à sa famille et à ses animaux des qualificatifs inspirés des arts martiaux : son mari est « kickin’ », ses fils « sparring », son chat un « ninja », son chien un « samouraï » et ses tortues « zen ». Cette caractérisation enjouée évoque un foyer animé et plein d’imagination.

Télécharger le PDF

Pour garder le résumé de Learning React pour plus tard, téléchargez gratuitement le PDF. Vous pouvez l’imprimer ou le lire hors ligne quand vous le souhaitez.
Download PDF

Télécharger l'EPUB

Pour lire le résumé de Learning React sur votre liseuse ou dans une application de lecture, téléchargez gratuitement l’EPUB. Le format numérique .epub est idéal pour lire des livres numériques sur téléphone, tablette ou liseuse.
Download EPUB
Envie de lire le livre complet ?
Suivre
Écouter
Accueil
Swipe
Biblio
Appli
Essayez l'accès complet pendant 3 jours
Écoutez, enregistrez, et plus encore
Comparer les fonctionnalités Gratuit Pro
📖 Lire les résumés
Lisez des résumés illimités. Les utilisateurs gratuits en reçoivent 3 par mois
🎧 Écouter les résumés
Écoutez des résumés illimités dans 40 langues
—
❤️ Favoris illimités
Limité à 4 pour les utilisateurs gratuits
—
📜 Historique illimité
Limité à 4 pour les utilisateurs gratuits
—
📥 Téléchargements illimités
Limité à 1 pour les utilisateurs gratuits
—
Calendrier sans engagement
Aujourd'hui : Accès immédiat
Écoutez les résumés complets de plus de 26 000 livres. Soit plus de 12 000 heures d'audio !
Jour 2 : Rappel d'essai
Nous vous enverrons une notification pour vous informer que votre essai se termine bientôt.
Jour 3 : Votre abonnement commence
Vous serez débité le 24 nov.,
annulez à tout moment avant.
Consume 2.8× More Books
2.8× livres de plus Écoute Lecture
Nos utilisateurs nous adorent
600,000+ lecteurs
Trustpilot Rating
TrustPilot
4.6 Excellent
Ce site change tout. Je n'ai jamais lu autant de résumés aussi rapidement. Je recommande vivement.
— Dave G
Ça vaut vraiment le coup en temps et en argent, et c'est très bien fait. Je n'ai jamais vu cette qualité de résumés ailleurs. Très utile !
— Em
Hautement recommandé !! Service fantastique. Parfait pour ceux qui veulent plus qu'un aperçu sans tous les détails d'un livre audio complet.
— Greg M
Économisez 62 %
Annuel
$119.88 $44.99/an/an
$3.75/mois
Mensuel
$9.99/mois
Démarrer un essai gratuit de 3 jours
3 jours gratuits, puis $44.99/an. Annulez à tout moment.
Unlock a world of fiction & nonfiction books
Plus de 26 000 livres pour le prix de 2 livres
Lisez n'importe quel livre en 10 minutes
Découvrez de nouveaux livres comme sur Tinder
Demandez n'importe quel livre s'il n'est pas encore résumé
Lisez plus de livres que quiconque
L'appli n°1 pour les amateurs de livres
Lifelike & immersive summaries
Garantie satisfait ou remboursé 30 jours
Téléchargez les résumés en EPUB ou PDF
Annulez à tout moment en quelques clics

Pourquoi un seul résumé ?

Scanner
Trouvez un code-barres à scanner

⭐
⭐
⭐
Nous avons un cadeau spécial pour vous
Ouvrir
38 % de réduction
RÉDUCTION POUR VOUS
⭐
⭐
⭐
$79.99
$49.99/an
Seulement $4.16 par mois
Continuer
2 touches pour commencer, résiliation ultra simple
Paramètres
Général
Widget
Chargement...