Points clés
Considérez l’interface comme une description de l’état, et non comme un amas de commandes DOM
React commence par les mises à jour. Avant React, les développeurs repéraient souvent des éléments dans le navigateur, leur associaient des gestionnaires d’événements, modifiaient du texte ou des attributs, et suivaient séparément les états d’attente, de réussite et d’échec. Un bouton « J’aime » constituait déjà une petite machine à états, et une page plus complexe multipliait les risques de désaccord entre JavaScript et le navigateur sur ce qui était affiché à l’écran.
Décrivez plutôt le résultat. React permet à un composant d’exprimer l’apparence que devrait avoir l’interface selon son état actuel. React réconcilie ensuite cette description avec le DOM du navigateur. Ce modèle déclaratif ne détermine pas la signification de l’état de l’application, mais centralise la façon dont l’état devient une interface. Les composants permettent aussi aux équipes de réutiliser et de composer des éléments d’interface, plutôt que de coordonner des modifications dispersées du DOM.
Le changement essentiel ne consiste pas simplement à écrire moins de lignes de code. Il tient au déplacement de la complexité : le code impératif demande aux développeurs de se souvenir de chaque modification, tandis que le code déclaratif leur demande de modéliser clairement l’état souhaité. Le raisonnement local et les tests s’en trouvent facilités, car on peut examiner le résultat d’un composant en fonction de ses entrées. En contrepartie, les abstractions peuvent masquer les coûts et le comportement. La syntaxe déclarative permet d’exprimer plus facilement l’intention, mais la qualité de la conception de l’état et le jugement en matière de performances restent de la responsabilité du développeur.
Faites circuler les données dans un seul sens pour que chaque changement d’écran ait une origine explicable
React a écarté la synchronisation bidirectionnelle. Les outils précédents abordaient différemment le même problème. jQuery facilitait les modifications directes de la page, mais l’état se retrouvait dispersé dans le code et le DOM. Backbone organisait les modèles et les vues, tandis que Knockout utilisait des observables et des liaisons. AngularJS a popularisé la liaison automatique bidirectionnelle, qui pouvait devenir difficile à comprendre dans les grandes applications.
React a rendu explicite le cheminement des mises à jour. Son flux de données unidirectionnel signifie que l’état se propage vers l’interface, tandis que les actions de l’utilisateur déclenchent des mises à jour qui produisent une nouvelle description de l’interface. L’architecture Flux a prolongé cette idée avec des actions, un répartiteur, des magasins et des vues React. Cela ne signifie pas que chaque application a besoin de Flux. L’essentiel est qu’un chemin lisible reliant l’événement à l’état, puis à l’écran, facilite la recherche des bogues. React privilégie également les mises à jour immuables de l’état: chaque changement produit un nouvel instantané plutôt qu’une mutation cachée.
Un cheminement unidirectionnel transforme le débogage en recherche de cause : repérer l’action, localiser la transition d’état et examiner le résultat affiché. Cela rappelle les systèmes événementiels dans lesquels une entrée consignée permet d’expliquer une sortie. L’avantage est maximal lorsque la propriété de l’état est clairement définie ; centraliser toutes les valeurs dans un magasin géant ne ferait que déplacer la confusion. L’approche de React est particulièrement utile lorsque les équipes conservent l’état à proximité des composants qui en ont besoin et organisent délibérément son partage entre composants.
Lisez JSX comme un langage compilé, et non comme du HTML dans du JavaScript
JSX est une syntaxe simplifiée. Elle permet aux développeurs d’écrire une interface arborescente dans une notation familière, proche du HTML, avec des expressions JavaScript entre accolades. Un compilateur transforme cette notation en appels JavaScript ordinaires qui créent des éléments React. Par exemple, une balise de composant comportant une propriété et du texte enfant devient un appel de fonction contenant le type du composant, ses props et ses enfants.
Le compilateur explique l’outillage. Un pipeline classique découpe le texte source en jetons, analyse ces jetons pour produire un arbre syntaxique, puis génère le code de sortie. Babel et des outils similaires savent interpréter JSX et le traduire avant que le navigateur ne le reçoive. Les expressions JSX peuvent calculer des valeurs ou parcourir des listes, mais elles ne peuvent pas contenir de blocs d’instructions, comme une instruction if. Cette syntaxe est facultative, mais des appels createElement imbriqués deviennent vite plus difficiles à lire.
Considérer JSX comme un langage destiné au compilateur permet de comprendre pourquoi les outils de compilation ne sont pas un simple ornement. Ils font partie du modèle de programmation, comme un langage de requête de base de données dépend d’un analyseur et d’un planificateur. JSX rapproche aussi structure et logique, ce que certains développeurs trouvent plus clair et d’autres moins bien séparé. Le critère pratique est de savoir si le composant reste compréhensible, et non si le balisage et la logique se trouvent dans des fichiers distincts.
Utilisez Fiber pour préparer, interrompre et hiérarchiser le travail d’interface avant de le valider
Le DOM virtuel est une description. Les éléments React sont des objets légers qui décrivent l’interface souhaitée. Lorsque l’état change, React crée une nouvelle description et la réconcilie avec la précédente, puis applique les modifications nécessaires à l’environnement hôte. Cette abstraction évite d’avoir à gérer manuellement les mises à jour du DOM, mais ne rend pas chaque rendu gratuit et ne garantit pas que React soit plus rapide que toutes les techniques d’accès direct au DOM.
Fiber rend le rendu interruptible. Un Fiber est l’enregistrement interne, de plus longue durée, d’un composant et du travail qui lui est associé. React conserve un arbre courant et construit un arbre de travail en cours. Pendant la phase de rendu, il peut préparer les modifications hors écran; pendant la phase de validation, il les applique. L’ancien réconciliateur en pile traitait les mises à jour de façon séquentielle et bloquante. Fiber permet d’interrompre ou d’abandonner le travail moins prioritaire, tandis que le regroupement rassemble les mises à jour avant leur application au DOM.
La distinction essentielle sépare le calcul d’une interface possible de son affichage effectif. Cette conception en deux étapes ressemble à la préparation d’une transaction avant la publication de ses effets : on peut abandonner un travail inachevé sans laisser l’écran à moitié mis à jour. La principale valeur du DOM virtuel tient donc à une combinaison de contrôle, de portabilité et de planification gérable des mises à jour, et non à un avantage universel en matière de vitesse. Les manipulations directes du DOM peuvent être plus rapides dans des cas étroitement contrôlés, mais elles transfèrent à l’application la charge de la coordination et de la fiabilité.
Mémorisez les goulets d’étranglement mesurés et ne stabilisez les références que là où c’est utile
La mémoïsation échange du travail contre de la gestion supplémentaire. `React.memo` peut éviter de rappeler un composant lorsque ses props sont jugées égales. `useMemo` peut mettre en cache un calcul coûteux, et `useCallback` peut préserver une référence de fonction. Ces outils sont utiles parce que React rappelle normalement les composants descendants lorsqu’un ancêtre est rendu à nouveau, même si le résultat de certains enfants ne changerait pas.
Le hic, c’est l’identité des références. Par défaut, React.memo effectue une comparaison superficielle. Deux tableaux au contenu identique restent différents si chaque rendu crée un nouvel objet tableau. De même, une nouvelle fonction de rappel peut neutraliser la mémoïsation lorsqu’elle est transmise à un enfant mémorisé. Mémoïsez une liste filtrée ou une fonction de rappel lorsqu’il en résulte une réduction notable du travail répété, par exemple le rendu coûteux d’un composant enfant. N’enveloppez pas par réflexe les calculs scalaires élémentaires ni tous les gestionnaires d’événements. La mémoïsation est un indice de performance, pas une garantie absolue contre les nouveaux rendus.
C’est un bon antidote à l’optimisation rituelle. La mise en cache a un coût : suivi des dépendances, comparaisons et complexité conceptuelle supplémentaire. Un calcul simple peut coûter moins cher que la gestion d’un cache, tandis qu’un sous-arbre coûteux peut justifier cette complexité. Le profilage apporte les éléments qui manquent en montrant où le temps est réellement passé. La leçon de conception plus profonde consiste à réduire structurellement le travail inutile — par exemple en plaçant l’état près des éléments qui l’utilisent — avant d’ajouter de la mémoïsation autour d’une arborescence de composants enchevêtrée.
Donnez la priorité aux saisies urgentes plutôt qu’aux résultats coûteux grâce aux transitions et aux valeurs différées
Toutes les mises à jour ne sont pas également urgentes. Fiber permet à React de planifier le travail de rendu selon différents niveaux de priorité, de sorte que la saisie ou les clics restent réactifs pendant qu’une mise à jour coûteuse de liste ou de page attend. `useTransition` marque une mise à jour d’état comme non urgente et indique si cette transition est en attente. `useDeferredValue` permet à un composant d’utiliser temporairement une ancienne valeur, tandis que React donne la priorité au travail plus urgent.
Choisissez le bon délai. Un résultat de recherche différé peut prendre un léger retard sur la saisie sans ralentir celle-ci. Contrairement à l’antirebond, qui attend une période d’inactivité déterminée, le rendu différé s’adapte au temps de traitement disponible et peut être interrompu par une nouvelle saisie. L’antirebond et la limitation de fréquence restent utiles pour limiter les requêtes réseau ou la fréquence des événements. Le travail concurrent comporte aussi des risques de cohérence appelés « déchirement » (tearing), lorsque des composants peuvent observer des instantanés différents d’un état externe; `useSyncExternalStore` fournit un mécanisme d’instantané cohérent.
La réactivité dépend autant de la priorité perçue que de la vitesse brute. Les utilisateurs tolèrent plus facilement l’arrivée un peu tardive d’un résultat que l’absence de réaction d’un champ de saisie à une frappe. Les outils de planification de React inscrivent cette distinction dans le modèle de mise à jour. Mais différer n’est pas approprié pour tous les changements d’état : une information périmée peut induire en erreur lorsque l’exactitude est essentielle. Les équipes doivent décider quelles parties de l’interface peuvent prendre du retard et signaler clairement ce décalage, plutôt que de considérer la concurrence comme une amélioration automatique de l’expérience utilisateur.
Envoyez rapidement du HTML utile, puis hydratez uniquement ce qui nécessite une interaction
Le rendu côté client seul retarde l’affichage du contenu utile. Le navigateur peut devoir télécharger, analyser et exécuter JavaScript avant que la page apparaisse, et les données récupérées ensuite peuvent créer une cascade de requêtes réseau. Le rendu côté serveur envoie du HTML qui peut être affiché et indexé plus tôt; l’hydratation associe ensuite le comportement React à ce balisage. L’hydratation suppose que le résultat produit par le serveur et la structure de composants attendue par le client correspondent.
Le rendu en flux améliore l’enchaînement. `renderToString` produit de façon synchrone la chaîne HTML complète, ce qui peut retarder la première réponse et consommer beaucoup de mémoire. Les API de rendu en flux peuvent envoyer plus tôt les portions prêtes et fonctionner avec les solutions de repli Suspense pendant que le reste du contenu est préparé. Le rendu côté serveur n’est pas une solution miracle: l’hydratation sollicite toujours le client, et le rendu HTML ne règle pas automatiquement les problèmes de sécurité tels que les attaques CSRF. La bonne approche dépend du contenu, des contraintes des appareils, de la fraîcheur des données et des besoins d’interaction de l’application.
Le rendu côté serveur met en pratique l’amélioration progressive : fournir d’abord un contenu utile, puis ajouter des comportements plus riches là où ils sont pertinents. C’est particulièrement important lorsque l’appareil ou la connexion rendent coûteux le téléchargement d’un gros volume de JavaScript. Pourtant, la rapidité apparente du premier affichage peut être trompeuse si la page reste inutilisable pendant une longue hydratation. Les performances doivent être évaluées sur l’ensemble de l’expérience — premier contenu affiché, disponibilité des interactions et navigation ultérieure — et non sur la seule arrivée du HTML.
Confiez le routage et la gestion des données aux frameworks lorsque leurs conventions apportent plus qu’elles ne coûtent
React laisse l’architecture ouverte. Cette liberté oblige les équipes à résoudre elles-mêmes les questions de routage, de chargement des données, de rendu côté serveur et de mutations. Les frameworks regroupent ces préoccupations récurrentes dans des conventions. Le livre présente un framework minimal avec des pages rendues côté serveur, des routes fondées sur le système de fichiers et des fonctions de chargement des données exportées. Cela aide à comprendre des conventions comme les exports de pages par défaut et les dossiers de routes comme des mécanismes, plutôt que comme des règles arbitraires.
Choisissez délibérément les compromis. Remix associe les chargeurs et les actions aux routes et s’appuie sur les formulaires natifs et le comportement du navigateur, ce qui favorise l’amélioration progressive. Next.js met l’accent sur le rendu côté serveur et le rendu statique, le routage fondé sur le système de fichiers et les actions serveur, avec des composants client lorsque l’interaction le nécessite. Les frameworks peuvent améliorer la cohérence et fournir des optimisations, mais ils entraînent des coûts d’apprentissage, de dépendances et de débogage. Choisissez en fonction des besoins du projet et de la familiarité de l’équipe, sans supposer qu’un seul framework convient à toutes les applications.
Un framework est un ensemble de décisions prises à l’avance. Cela peut accroître la productivité lorsqu’une équipe rencontre régulièrement les mêmes questions d’architecture : des conventions partagées réduisent les débats locaux et les implémentations incohérentes. En contrepartie, ces conventions peuvent ne pas correspondre aux contraintes d’un produit donné. Comme le fait le livre, construire une petite version du mécanisme sous-jacent permet d’évaluer utilement une abstraction : on voit à la fois le travail qu’elle élimine et les hypothèses qu’elle introduit.
Utilisez les composants serveur pour exclure du paquet client le code fortement dépendant des données
Les composants serveur et client ont des rôles différents. Un composant serveur s’exécute sur le serveur et son code de composant n’est pas envoyé au client. Il peut accéder aux données côté serveur et y attendre la fin d’opérations. Un composant client prend en charge les interactions dans le navigateur, l’état local et les gestionnaires d’événements. Le serveur peut également rendre les composants client en HTML initial; la distinction concerne donc l’endroit où le code est disponible et où s’exécute le comportement interactif continu.
Cette frontière obéit à des règles. Les props transmises du serveur au client doivent pouvoir être sérialisées, et un composant client ne peut pas importer un composant serveur, car cela pourrait entraîner des dépendances réservées au serveur dans un paquet destiné au navigateur. À la place, un composant serveur peut transmettre à un composant client un enfant déjà rendu. Les outils de regroupement doivent créer des graphes de modules distincts pour le serveur et le client et résoudre les références entre eux. Les actions serveur rendent des fonctions serveur accessibles aux interactions côté client, souvent par l’intermédiaire de formulaires, mais leur mise en place nécessite la prise en charge du framework et des outils de regroupement pour acheminer les requêtes réseau.
L’avantage architectural tient à la sélectivité de ce qui est envoyé : une page peut conserver l’accès aux données et le rendu côté serveur, tout en réservant le JavaScript du navigateur aux zones réellement interactives. C’est plus précis que de traiter une route entière comme exclusivement côté serveur ou côté client. Cette frontière entraîne aussi une charge cognitive, surtout lorsque les interactions et les dépendances aux données sont étroitement liées. La question utile n’est pas de savoir si les composants serveur sont supérieurs, mais si le déplacement d’un composant donné de l’autre côté de la frontière réduit sensiblement le travail du client sans rendre son comportement plus difficile à maintenir.
Choisissez entre le nouveau rendu de composants entiers et les signaux fins en comprenant leurs coûts
React effectue des mises à jour à gros grain. Lorsque l’état change, React exécute à nouveau un composant, puis réconcilie son résultat. Les systèmes fondés sur les signaux, comme celui de Solid, suivent les expressions qui lisent une valeur et mettent à jour ces parties précises sans réexécuter le composant entier. Vue, Angular et Svelte proposent leurs propres mécanismes réactifs, tandis que Svelte compile également les composants en mises à jour directes du DOM.
Les différentes stratégies déplacent les coûts. La réactivité fine peut éviter les nouveaux rendus étendus, tandis que le modèle explicite de React, fondé sur l’état et la réconciliation, offre un modèle mental clair à l’échelle du composant. Qwik met l’accent sur la reprise (resumability): il envoie un instantané initial rendu côté serveur et charge le comportement à la demande, plutôt que d’hydrater toute l’application de la manière conventionnelle. React Forget, présenté dans le livre de 2024 comme un outil en cours de développement, vise à automatiser la mémoïsation. Il s’agit de choix d’ingénierie différents, et non d’un classement simple des frameworks.
Comparer les frameworks est utile, car cela révèle que le problème commun — maintenir la concordance entre l’état et l’interface — admet plusieurs solutions viables. Les signaux rendent les dépendances explicites à une échelle plus fine ; React place au centre l’exécution des composants et la réconciliation. Les approches pilotées par le compilateur peuvent déplacer des décisions de l’exécution vers la compilation, tandis que la reprise vise à réduire le coût du démarrage. Chaque stratégie déplace la complexité. Il faut donc tester les affirmations sur les performances à l’aune de charges de travail réelles, du comportement des paquets et des capacités de l’équipe, plutôt que de les déduire du modèle mis en avant par un framework.
Analyse
Fluent React est un ouvrage explicatif à visée technique, destiné aux développeurs qui savent déjà créer des interfaces React, mais souhaitent comprendre les mécanismes qui les sous-tendent. Sa structure élargit progressivement la perspective de façon judicieuse: d’abord le problème historique des mises à jour d’interface, puis JSX et la réconciliation, ensuite les performances et la concurrence, enfin le rendu côté serveur, les frameworks, les composants serveur et les solutions de remplacement. L’idée récurrente est que la contribution la plus durable de React n’est pas une optimisation particulière, mais un modèle géré qui transforme l’état en interface.
Le livre est difficile à résumer, car il mêle des concepts durables à des descriptions détaillées de mécanismes internes susceptibles d’évoluer d’une version de React à l’autre. Son procédé pédagogique le plus convaincant consiste à reconstituer les approches antérieures — des mises à jour manuelles du DOM au MVC et à la liaison de données — avant d’expliquer l’attrait des mises à jour unidirectionnelles des composants. Il construit également un mini-framework et un moteur simplifié de rendu des composants serveur, ce qui rend concrètes les conventions et les exigences des outils au lieu de les présenter comme des éléments magiques.
Une lecture critique doit distinguer l’argument conceptuel des affirmations trop générales. Le DOM virtuel fournit une description structurée et une stratégie de réconciliation, mais il n’est pas intrinsèquement plus rapide que les opérations directes sur le DOM dans tous les cas. Le rendu côté serveur peut accélérer l’affichage initial du contenu, mais ne garantit à lui seul ni l’interactivité, ni l’accessibilité, ni la sécurité, ni une meilleure visibilité dans les moteurs de recherche. Le texte reconnaît les compromis liés à l’hydratation, au rendu en flux, à la mémoïsation et à la dépendance envers un framework, même si son ton enthousiaste donne parfois l’impression que les avantages de React sont plus automatiques qu’ils ne le sont réellement.
La leçon la plus transposable consiste à comprendre quelles responsabilités une abstraction prend en charge et lesquelles elle laisse à l’application. React gère le travail de rendu, mais les développeurs restent responsables de la sémantique de l’état, des frontières entre les données et de la définition d’une latence acceptable. De même, les frameworks fournissent des conventions tout en retirant une part de contrôle. Un ingénieur aguerri n’a pas besoin de mémoriser chaque champ interne ou chaque nom de voie de priorité. La compétence la plus précieuse est de suivre une mise à jour depuis l’événement jusqu’à l’état, à la planification, au rendu et à la validation visible, puis de décider si ce cheminement convient à l’expérience réelle de l’utilisateur.
Résumé des avis
Fluent React reçoit des avis partagés, avec une note globale de 4,18/5. Les lecteurs apprécient son étude approfondie des mécanismes internes de React, de Fiber et des algorithmes de réconciliation. Cependant, certains jugent certains chapitres peu pertinents ou tendancieux. Le livre est salué pour son approche exhaustive, mais critiqué parce qu’il mêle des contenus destinés aux débutants et aux lecteurs avancés. Bien qu’il soit utile pour comprendre le fonctionnement interne de React, il n’est pas recommandé aux novices. Les critiques le considèrent comme une lecture indispensable pour les développeurs React expérimentés qui souhaitent approfondir leurs connaissances, malgré quelques réserves sur sa structure et son contenu.
Les lecteurs ont aussi lu
Glossaire
JSX
Syntaxe JavaScript pour les interfaces utilisateurJSX est une extension syntaxique de JavaScript qui permet d’exprimer des arbres d’interface utilisateur à l’aide de balises de type HTML et d’expressions JavaScript intégrées. Les navigateurs ne l’interprètent pas directement. Un compilateur le transforme en JavaScript qui crée des éléments React, ce qui permet de conserver une structure de composants lisible tout en prenant en charge les calculs et la composition habituels.
DOM virtuel
Description d’interface en mémoireLe DOM virtuel est une représentation légère d’une interface prévue, exprimée au moyen d’éléments React plutôt que de nœuds du DOM du navigateur. Lorsqu’une mise à jour survient, React crée une nouvelle description, la réconcilie avec la précédente, puis applique les changements à l’environnement hôte. Sa valeur tient notamment à la structuration des mises à jour et à l’abstraction qu’il offre, et non à une garantie de rapidité universelle.
Réconciliation
Planification des changements d’interfaceLa réconciliation est le processus par lequel React compare une nouvelle description de l’interface à la précédente et détermine le travail nécessaire pour aligner l’environnement hôte. Elle peut repérer les éléments modifiés, ajoutés, supprimés ou réordonnés. Avec Fiber, le travail de rendu peut être préparé séparément de la phase de commit qui rend les changements visibles.
Réconciliateur Fiber
Architecture de rendu interruptibleLe réconciliateur Fiber est l’architecture de rendu de React, fondée sur des enregistrements Fiber persistants représentant les composants et le travail qui leur est associé. Il prend en charge un arbre courant et un arbre en cours de construction, ce qui permet à React de préparer les mises à jour, de prioriser le travail et parfois de mettre le rendu en pause ou de l’abandonner avant de valider les changements apportés à l’interface.
Architecture Flux
Modèle d’état unidirectionnelFlux est un modèle architectural popularisé par Facebook pour gérer le flux de données d’une application. Les actions décrivent des événements ou des entrées, un répartiteur les transmet aux magasins, les magasins mettent à jour l’état de l’application et les vues React reflètent les résultats. Son idée centrale est un cycle unidirectionnel prévisible, plutôt que des mises à jour directes circulant de façon imprévisible entre les vues et les données.
Hydratation
Rendre le HTML du serveur interactifL’hydratation est le processus côté client qui associe le comportement de React au HTML rendu sur le serveur. Le navigateur charge le code de l’application, React fait correspondre le balisage existant à la structure des composants, puis la gestion des événements devient active. Si les structures produites par le serveur et le client diffèrent, l’hydratation peut échouer ou entraîner un comportement inattendu.
Composants serveur React (RSC)
Composants React exécutés sur le serveurLes composants serveur React s’exécutent sur le serveur et leur code de composant est exclu du bundle client. Ils peuvent accéder aux données côté serveur et effectuer des tâches asynchrones, puis contribuer au rendu de l’application. Les composants client interactifs gèrent l’état et les événements du navigateur. Ce modèle nécessite des outils capables de séparer les graphes de modules serveur et client et de faire communiquer les deux côtés de leur frontière.
Actions serveur
Fonctions appelables côté serveurLes actions serveur sont des fonctions réservées au serveur que les interactions côté client peuvent invoquer au moyen d’un mécanisme réseau pris en charge par un framework. Un formulaire peut transmettre ses données à une action, et d’autres codes client peuvent en appeler une au cours d’une interaction. Les arguments et les valeurs de retour doivent être transmis entre les environnements ; les bundlers et les frameworks gèrent donc les références et les requêtes nécessaires.
useTransition
Marquer les mises à jour comme non urgentesuseTransition est un hook React qui renvoie une fonction permettant de marquer des mises à jour d’état comme des transitions, ainsi qu’un indicateur d’attente. Les mises à jour de transition ont une priorité inférieure à celle des mises à jour urgentes liées aux interactions, comme la saisie au clavier. React peut en différer le rendu pour préserver la réactivité, mais les développeurs doivent déterminer si l’affichage retardé du contenu concerné est acceptable.
useDeferredValue
Différer une valeur changeanteuseDeferredValue renvoie une version d’une valeur que React peut mettre à jour avec une priorité inférieure à celle des tâches urgentes. Cette fonction sert souvent à permettre à un champ de saisie d’afficher immédiatement chaque frappe, tandis que les résultats coûteux sont mis à jour lorsque du temps de rendu est disponible. Contrairement à un délai fixe de temporisation, le report s’adapte à l’ordonnancement de React et au temps de traitement disponible.
Signaux
Valeurs réactives suiviesLes signaux sont des conteneurs de valeurs réactives qui repèrent les endroits où leurs valeurs sont lues et avertissent les calculs dépendants lorsque ces valeurs changent. Les systèmes fondés sur les signaux peuvent mettre à jour des expressions ou des régions d’interface précises sans réexécuter un composant entier. Les frameworks ont des API et des implémentations différentes, mais le suivi des dépendances est le mécanisme fondamental décrit dans le livre.
Reprise (resumability)
Reprendre le comportement rendu sur le serveurLa reprise est une approche dans laquelle le serveur envoie une page rendue accompagnée des informations sérialisées nécessaires à l’activation du comportement à la demande. Au lieu de réexécuter immédiatement l’application au moyen de l’hydratation classique, le client peut reprendre à partir de l’instantané fourni par le serveur et charger le code au gré des interactions. Le livre présente Qwik comme un framework fondé sur cette idée.
React Forget
Mémorisation automatique dans ReactReact Forget est un ensemble d’outils de compilation que le livre décrit comme étant en cours de développement. Il vise à analyser le code React et à y insérer automatiquement de la mémorisation. Son objectif est de réduire le travail inutile des composants sans obliger les développeurs à ajouter manuellement React.memo, useMemo ou useCallback partout dans une application. Dans le compte rendu de 2024 présenté par le livre, l’outil n’est pas encore généralement disponible.
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.