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
Apprendre les modèles de conception JavaScript, 2e édition

Apprendre les modèles de conception JavaScript, 2e édition

Titre original: Learning JavaScript Design Patterns
Concevez des systèmes JavaScript qui restent faciles à maintenir à mesure qu’ils grandissent, sans traiter les modèles comme des règles.
par Addy Osmani 2011 296 pages
3.83
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

Considérez les modèles comme des options éprouvées, et non comme des gabarits à imposer.

Les modèles sont des hypothèses. Un modèle de conception est une manière réutilisable de résoudre un problème logiciel récurrent, et non une solution toute faite à copier dans chaque projet. Cette idée s’est développée à partir des travaux de l’architecte Christopher Alexander sur les formes de conception récurrentes, puis s’est imposée en informatique grâce au catalogue de 23 modèles orientés objet du Gang of Four. Sa valeur tient au vocabulaire commun qu’il offre et au point de départ éprouvé qu’il propose, non à l’obéissance à une recette.

Examinez les éléments probants. Un modèle proposé qui n’a pas été examiné à la loupe est un proto-modèle (proto-pattern). La règle des trois présentée dans le livre demande s’il fonctionne, pourquoi il est utile et s’il s’applique au-delà d’un seul cas. À l’inverse, un anti-modèle décrit une approche séduisante qui tend à causer des problèmes, comme la pollution des variables globales ou la modification des prototypes des objets intégrés.

Analyse

Ce qui est utile ici, c’est la distinction entre donner un nom à une solution et la valider. Une étiquette peut faciliter la discussion d’une conception, mais elle peut aussi lui conférer une autorité qu’une solution de circonstance ne mérite pas. Les critères du livre incitent les équipes à exiger récurrence et éléments probants avant de standardiser une technique. Cette rigueur est particulièrement importante lorsqu’un modèle ajoute de la structure : si les développeurs ne peuvent expliquer quel problème cette structure résout, le modèle risque de relever du cérémonial plutôt que d’être un véritable levier.

Définissez explicitement les frontières des modules avant que les dépendances ne s’emmêlent à l’échelle globale.

Exposez une interface délibérée. Un module JavaScript regroupe des fonctionnalités liées, importe ce dont il a besoin et exporte les éléments que les autres parties du code peuvent utiliser. Les modules ES donnent à chaque fichier sa propre portée, réduisant les collisions accidentelles de noms et rendant les dépendances visibles. Un module peut dissimuler ses détails internes tout en offrant une petite interface publique, à la manière d’une porte bien signalée donnant sur une grande pièce.

Chargez avec discernement. Les imports statiques chargent les dépendances dans le graphe initial des modules. Les imports dynamiques renvoient une promesse et permettent à une application de récupérer un module au moment où elle en a besoin, par exemple après un clic ou lorsqu’un composant approche de la zone visible. Les modules facilitent aussi la réutilisation et la maintenance, tandis que les outils de regroupement peuvent supprimer les exports inutilisés grâce à l’élimination du code mort (tree-shaking).

Analyse

Une dépendance visible est plus facile à comprendre qu’une dépendance globale cachée : on peut suivre les changements dans le graphe des imports au lieu de les découvrir à travers des interactions fortuites. Ce n’est pas seulement un avantage en matière d’organisation du code ; c’est aussi une façon de rendre les hypothèses d’un système vérifiables. En revanche, la modularité ne garantit pas à elle seule une bonne conception. Un projet peut compter des centaines de fichiers minuscules tout en restant étroitement couplé si leurs interfaces exposent trop de choses ou si leurs responsabilités se chevauchent.

N’ajoutez des fabriques, des décorateurs ou du partage que si la variabilité justifie une couche supplémentaire.

Choisissez le modèle en fonction du besoin. Une fabrique dissimule la création d’objets derrière une interface; elle est utile lorsque la configuration détermine le type d’objet à construire. L’exemple des véhicules présenté dans le livre crée soit une voiture, soit un camion sans obliger les appelants à gérer chaque constructeur. Un décorateur ajoute des fonctionnalités en enveloppant un objet: un ordinateur portable de base peut être enrichi successivement de mémoire, d’une gravure et d’une assurance, au lieu de nécessiter une sous-classe pour chaque combinaison.

Partagez les données répétées. Le poids mouche (Flyweight) réduit l’utilisation de mémoire en stockant une seule fois les données intrinsèques communes et en conservant ailleurs les données extrinsèques qui changent. Une bibliothèque peut partager un objet de métadonnées pour les exemplaires d’un livre, tandis que les informations d’emprunt restent dans des enregistrements distincts. Ces modèles ajoutent un niveau d’indirection; la construction directe est donc souvent plus claire dans les cas simples. Le Singleton, qui impose une instance partagée unique, appelle lui aussi à la prudence, car un état partagé caché complique les tests.

Analyse

Ces modèles répondent à trois types de besoins différents : la variabilité de la création, la multiplication combinatoire des fonctionnalités et la duplication des données. Cette distinction permet d’éviter l’erreur courante qui consiste à traiter les modèles comme des formes interchangeables de sophistication. L’exemple du décorateur est particulièrement utile, car il montre pourquoi créer une sous-classe pour chaque combinaison de fonctionnalités passe mal à l’échelle. Pourtant, chaque couche supplémentaire constitue un nouvel élément à examiner lors du débogage ; le critère pratique consiste donc à se demander si elle réduit davantage la complexité que l’appelant doit gérer qu’elle n’accroît celle que les responsables de la maintenance doivent comprendre.

Acheminez les événements de manière souple, mais confiez les décisions de flux de travail à un responsable clairement identifié.

Notifiez sans établir de liens rigides. Dans le modèle Observateur, un sujet suit les observateurs intéressés et les informe lorsque son état change. Un modèle de données boursières peut, par exemple, informer à la fois une grille d’affichage et un compteur de mises à jour. Le modèle publication/abonnement ajoute un canal d’événements entre les émetteurs et les abonnés, de sorte que les deux parties n’aient pas besoin de se connaître directement. Les abonnés doivent pouvoir se désinscrire lorsqu’ils n’ont plus besoin des mises à jour.

Séparez le signal de l’orchestration. Un agrégateur d’événements se contente principalement de relayer les messages. Un Médiateur, en revanche, prend en charge les décisions concernant la coordination de plusieurs objets, à la manière d’une tour de contrôle qui dirige les avions au lieu de laisser chaque appareil négocier avec tous les autres. Le couplage faible facilite la réutilisation, mais peut aussi rendre difficiles à repérer les écouteurs manquants ou les flux d’événements défaillants. Utilisez un médiateur lorsque le flux de travail lui-même a besoin d’un lieu clairement défini.

Analyse

Le découplage est puissant parce qu’il réduit le nombre de relations directes qu’un changement peut perturber. Mais une communication trop indirecte peut rendre la causalité difficile à reconstituer : un message est envoyé, sans qu’aucun participant ne sache nécessairement qui en dépend. La distinction entre un canal d’événements et un médiateur ramène une question architecturale essentielle : le système se contente-t-il de diffuser des informations, ou prend-il une décision coordonnée ? La réponse détermine où la responsabilité doit se situer.

Séparez les données, la présentation et la coordination sans confondre React avec MVC.

Attribuez une fonction à chaque couche. Dans MVC, les modèles contiennent les données métier, les vues les présentent et les contrôleurs traitent les entrées utilisateur et coordonnent les mises à jour. La conception originale de Smalltalk utilisait également des observateurs pour que les vues puissent réagir aux changements des modèles. MVP déplace la logique de présentation dans un présentateur, ce qui peut faciliter les tests des comportements complexes de l’interface grâce à une vue passive. MVVM utilise un modèle de vue pour exposer des données et des actions adaptées à la vue, souvent au moyen de la liaison de données.

Évaluez les frameworks d’après leur comportement. Ces appellations désignent des approches apparentées en matière de séparation, et non des implémentations identiques. React est avant tout une bibliothèque de rendu d’interface utilisateur, pas un framework MVC traditionnel doté d’un contrôleur central. Ses composants peuvent regrouper état local, rendu et flux de contrôle, tandis que les Hooks contiennent souvent une logique réutilisable. La question architecturale est de savoir comment circulent les données et les décisions, non quelle appellation un framework revendique.

Analyse

Ces distinctions historiques sont importantes, car elles évitent que l’image de marque d’un framework ne se substitue à l’analyse architecturale. Une équipe peut poser des questions concrètes : qui est responsable des données métier, qui réagit aux entrées utilisateur et qui met à jour l’affichage ? Ces questions font ressortir les responsabilités, même lorsqu’une bibliothèque ne correspond pas précisément à MVC, MVP ou MVVM. Il n’existe pas de séparation idéale universelle : des abstractions qui améliorent la testabilité ou le travail en parallèle peuvent devenir une comptabilité coûteuse lorsque l’interface est simple.

Utilisez les promesses pour rendre visibles l’enchaînement, la concurrence et les échecs des opérations asynchrones.

Représentez les opérations qui se terminent plus tard. Une promesse représente le succès ou l’échec éventuel d’une opération asynchrone. Enchaîner les promesses facilite le suivi des étapes successives, plutôt que de recourir à des fonctions de rappel profondément imbriquées, tandis que `catch` fournit un endroit où gérer les échecs. `async` et `await` offrent une manière d’écrire le même flux fondé sur les promesses qui donne davantage l’impression d’une exécution séquentielle; on les associe souvent à `try` et `catch`.

Choisissez la forme d’exécution. Utilisez `Promise.all` lorsque des requêtes indépendantes peuvent s’exécuter en parallèle et que leurs résultats sont nécessaires ensemble. Utilisez des appels successifs à `await` lorsqu’une tâche ultérieure dépend d’un résultat antérieur. Mettre en cache les résultats de promesses peut éviter les requêtes en double, et une logique de nouvelle tentative peut relancer une opération qui a échoué. Ces modèles sont particulièrement utiles pour les entrées-sorties réseau et fichier, où l’attente ne devrait pas empêcher les autres tâches de l’application de se poursuivre.

Analyse

Le gain essentiel ne tient pas à la simplification des opérations asynchrones, mais au fait que leur structure devient lisible. L’enchaînement, la concurrence et la gestion des erreurs sont des politiques différentes, et la syntaxe facilite l’examen de ces choix. Une mise en garde s’impose : exécuter des tâches en parallèle n’est approprié que si elles sont indépendantes, et la mise en cache n’est sûre que si le résultat stocké reste valable pour les besoins de l’appelant. Une syntaxe claire ne peut pas, à elle seule, déterminer ces aspects sémantiques.

Privilégiez les Hooks pour réutiliser une logique avec état, tout en préservant des contrats de composants clairs.

Réutilisez les comportements sans empiler les enveloppes. Un composant d’ordre supérieur (Higher-Order Component) reçoit un composant et renvoie une version dotée d’un comportement supplémentaire, par exemple le chargement de données ou l’application d’un style commun. Une propriété de rendu (Render Prop) transmet une fonction qui détermine ce qu’un composant affiche; cette fonction reçoit souvent des données provenant du composant. Ces deux approches permettent de partager de la logique, mais les enveloppes imbriquées et les propriétés implicites peuvent rendre le flux des données plus difficile à suivre.

Extrayez les opérations avec état. Les Hooks de React permettent aux composants fonctionnels d’utiliser un état et des effets, et les Hooks personnalisés permettent à plusieurs composants de réutiliser la même logique avec état. Par exemple, un Hook personnalisé de détection des pressions de touches peut installer des écouteurs clavier et les nettoyer ensuite. Remonter l’état dans un parent commun permet aux composants frères de partager des valeurs, bien qu’en remonter trop puisse déclencher des opérations inutiles. Context permet de partager des données dans un arbre de composants sans transmettre les propriétés à chaque niveau.

Analyse

Les Hooks déplacent la réutilisation de la manipulation de la structure des composants vers la composition de fonctions, ce qui peut faciliter la localisation et le partage des comportements. Cette amélioration n’est pas automatique : les dépendances des effets, le nettoyage et les règles relatives aux Hooks exigent toujours un raisonnement délibéré. Les composants d’ordre supérieur et les propriétés de rendu restent des outils compréhensibles lorsque leurs contrats au niveau des composants sont explicites. Le critère utile consiste à déterminer si une technique clarifie qui fournit les données et qui est responsable du comportement, et non si elle est la plus récente.

Ne livrez que le JavaScript nécessaire à l’écran affiché.

Différez le code qui n’est pas urgent. Les imports statiques placent les dépendances dans le graphe initial des modules; les imports dynamiques peuvent différer le chargement de fonctionnalités jusqu’à ce qu’une interaction, leur visibilité ou une navigation les rende pertinentes. Dans l’exemple d’application de messagerie du livre, le chargement du sélecteur d’émojis uniquement à la demande a réduit la taille initiale du bundle d’environ 1,5 Mio à 1,33 Mio. Le fractionnement par itinéraire permet de même d’envoyer le code de la page affichée plutôt que celui de toutes les pages à la fois.

Optimisez l’ensemble du parcours de livraison. Le modèle PRPL organise les performances autour de l’envoi des ressources essentielles, du rendu rapide du premier itinéraire, de la mise en cache anticipée des ressources utiles et du chargement différé des ressources moins utilisées. Le préchargement peut être utile lorsqu’une ressource essentielle risquerait autrement d’être découverte tardivement, mais son utilisation excessive entre en concurrence pour la bande passante. La virtualisation profite également aux longues listes: elle affiche les lignes visibles plutôt que des milliers d’éléments hors écran.

Analyse

Les performances relèvent autant de l’allocation des ressources que de la taille du code. Différer une fonctionnalité facultative peut améliorer la première visite, mais le délai est alors reporté au moment où l’utilisateur demande cette fonctionnalité. La mesure appropriée doit donc prendre en compte à la fois la réactivité initiale et la disponibilité au moment de l’interaction. De même, le préchargement n’est pas un gain de vitesse gratuit : donner la priorité à une ressource peut en retarder une autre. L’insistance du livre sur la mesure et les choix fondés sur les besoins des utilisateurs est plus pertinente que n’importe quelle règle unique de regroupement.

Choisissez le mode de rendu page par page, puis n’hydratez que ce qui justifie l’interactivité.

Adaptez le rendu au contenu. Le rendu côté client convient aux applications très interactives, mais peut nécessiter une quantité importante de JavaScript avant que du contenu utile apparaisse. Le rendu côté serveur peut fournir du HTML adapté à chaque requête, tandis que le rendu statique convient aux pages stables telles que les articles ou les informations sur une entreprise. La régénération statique incrémentale met à jour les pages générées sans reconstruire l’ensemble du site à chaque modification.

Rendez l’interactivité sélective. L’hydratation associe un comportement côté client au HTML rendu côté serveur. L’hydratation progressive retarde l’activation des composants moins essentiels; l’architecture en îlots (Islands architecture) conserve un HTML majoritairement statique et hydrate séparément différentes zones interactives. Un tableau de bord personnalisé peut justifier un rendu côté serveur, tandis qu’un blogue peut souvent être statique et comporter quelques fonctionnalités interactives limitées. Les applications hybrides peuvent adopter des approches différentes selon les itinéraires au lieu d’imposer partout un seul modèle de rendu.

Analyse

On passe ici du choix d’une identité unique pour toute l’application à une décision de déploiement prise page par page. Ce choix met en évidence des coûts concurrents : le travail côté serveur, le JavaScript côté client, l’actualité des données et le délai avant que l’interaction soit possible. Les îlots sont particulièrement convaincants lorsqu’une page est essentiellement composée de contenu et comporte quelques commandes, mais ils sont moins adaptés aux interfaces dont les comportements sont étroitement imbriqués. La cohérence architecturale a de la valeur, mais elle ne devrait pas primer sur la forme réelle de l’expérience utilisateur.

Organisez les fichiers autour des fonctionnalités qui évoluent, et ne partagez réellement que le code qui doit l’être.

Choisissez une structure qui suit le travail. Regrouper les fichiers par fonctionnalité garde à proximité le code, les styles et les tests d’un composant, ce qui facilite la localisation des changements apportés à une fonctionnalité. Le regroupement par type de fichier peut aider les nouveaux membres de l’équipe à trouver les styles ou les tests, mais les modifications d’une fonctionnalité peuvent alors s’étendre sur plusieurs dossiers. Une structure hybride sépare les composants et utilitaires partagés tout en plaçant côte à côte les fichiers propres à chaque fonctionnalité.

Gardez la navigation gérable. Le livre recommande d’éviter les dossiers profondément imbriqués, car le déplacement des fichiers et la gestion des imports relatifs deviennent plus difficiles. La logique Redux peut se trouver dans la tranche (slice) d’une fonctionnalité, qui regroupe ainsi ses actions et son réducteur. Les Hooks utilisés par un seul composant peuvent rester à proximité, tandis que les Hooks véritablement partagés ont leur place dans un emplacement commun. La meilleure structure reflète la manière dont l’équipe prévoit de faire évoluer l’application.

Analyse

La structure des dossiers est un modèle externe de la représentation mentale de l’équipe. Lorsque des fichiers associés changent ensemble, les garder à proximité réduit le nombre d’endroits qu’un développeur doit chercher et modifier. Mais il ne faut pas confondre proximité et duplication : le code copié dans chaque dossier de fonctionnalité peut diverger, tandis qu’un répertoire partagé tentaculaire risque de devenir un fourre-tout. Le bon équilibre consiste à centraliser les fonctionnalités stables et réutilisables, tout en gardant les décisions propres aux fonctionnalités, qui évoluent davantage, près de celles qui en sont responsables.

Analyse

Il vaut mieux lire ce livre comme une carte des choix de conception que comme un catalogue dont il faudrait appliquer toutes les entrées. Son argument central, toujours pertinent, est que la maintenabilité dépend de la lisibilité des relations: les imports de modules montrent les dépendances, les observateurs révèlent les circuits de notification, les médiateurs indiquent où se situe le déroulement du processus, et les architectures MV répartissent les responsabilités entre les données, la présentation et le contrôle. Le JavaScript moderne fournit des mécanismes intégrés pour de nombreuses structures qui nécessitaient autrefois des modèles élaborés; la valeur d’un modèle tient donc souvent moins à son code qu’au problème qu’il permet de mettre en évidence.

L’étendue du livre est à la fois son principal atout et son principal défi. Il relie les modèles au niveau des objets à la composition dans React, aux flux asynchrones, au regroupement de code, au rendu et à l’organisation des dossiers. Ces sujets se situent toutefois à des échelles différentes. Une fabrique modifie la façon dont les objets sont créés; l’architecture en îlots (Islands architecture) change la manière dont une page est livrée et activée. Les traiter simplement comme des modèles risque de laisser croire qu’il s’agit d’interventions de même ampleur. Les lecteurs devraient distinguer les décisions de conception locales des choix à l’échelle du système, puis se demander comment les unes et les autres interagissent.

Le meilleur critère pratique est comparatif: quelle complexité cette technique élimine-t-elle, quelle nouvelle complexité introduit-elle, et qui doit comprendre ce compromis? Un Singleton peut simplifier l’accès tout en dissimulant un état partagé. La publication/abonnement peut supprimer les dépendances directes tout en brouillant la responsabilité des événements. Les imports dynamiques peuvent réduire les téléchargements initiaux tout en retardant la disponibilité d’une fonctionnalité. Le livre invite à plusieurs reprises à faire ce bilan, et c’est l’habitude la plus utile à conserver lors des revues de code.

Certains exemples de code sont des illustrations pédagogiques plutôt que des recettes prêtes à l’emploi pour la production, et le paysage technologique continue d’évoluer. Cela ne leur enlève pas leur valeur. La leçon durable consiste à comprendre à quelle contrainte répond chaque modèle, à examiner ses coûts dans le cadre de travail actuel et à privilégier la structure la plus simple qui rende claires les relations importantes du système.

Résumé en 30 secondes
Les modèles de conception sont des points de départ utiles, pas des recettes : adoptez-en un s’il répond à un problème récurrent et si la complexité supplémentaire qu’il entraîne en vaut la peine. Des frontières de modules claires, un flux de données explicite et des décisions de flux de travail bien attribuées facilitent le suivi des dépendances. Les promesses rendent visibles l’ordre des opérations asynchrones, la concurrence et les échecs. Les imports dynamiques, l’hydratation sélective et les choix de rendu peuvent réduire le travail inutile pour chaque page. Organisez les fichiers en fonction de l’évolution des fonctionnalités et veillez à ce que le code partagé le soit réellement.
Contient des spoilers

Dernière mise à jour:

Signaler un problème

Résumé des avis

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

Apprendre les modèles de conception JavaScript, 2e édition reçoit des avis mitigés. Certains louent sa couverture complète des modèles de conception et ses exemples pratiques, tandis que d’autres le trouvent dépassé et trop centré sur certaines bibliothèques. Les avis positifs soulignent son utilité pour les développeurs de niveau intermédiaire et sa pertinence durable. Parmi les critiques figurent une révision éditoriale inégale, un contenu daté et une importance excessive accordée à jQuery. Beaucoup de lecteurs apprécient les explications du livre sur les modèles courants, mais estiment qu’il ne conviendra peut-être pas à ceux qui recherchent des techniques JavaScript de pointe. Dans l’ensemble, il est considéré comme une bonne introduction aux modèles de conception, malgré certaines limites.

Votre note :
4.32
233 évaluations
Envie de lire le livre complet ?

Glossaire

proto-modèle (proto-pattern)

un modèle candidat non validé

Une solution proposée à un problème de conception récurrent qui n’a pas encore été suffisamment examinée pour être reconnue comme un modèle fiable. Un proto-modèle peut être utile, mais les lecteurs devraient évaluer les preuves qui l’étayent, son contexte et sa portée au-delà d’un cas donné, plutôt que de supposer qu’il s’agit d’une pratique établie.

règle des trois

trois critères de récurrence

Un test permettant de déterminer si un modèle décrit une solution récurrente et largement utile. Il demande si le modèle remplit son objectif, pourquoi il est utile et s’il s’applique dans plus d’une situation limitée. Cette règle aide à distinguer une approche de conception réutilisable d’une implémentation ponctuelle.

modèle Module

encapsulation au moyen d’une API publique

Une façon d’organiser des fonctionnalités connexes tout en exposant certaines méthodes ou valeurs et en gardant privés les détails internes. Les versions classiques en JavaScript utilisaient des fermetures pour simuler la confidentialité. Les modules ES modernes fournissent une portée à l’échelle du fichier ainsi que des imports et des exports explicites, ce qui rend les dépendances et les interfaces publiques plus claires.

poids mouche (Flyweight)

stockage partagé des données répétées

Un modèle structurel qui réduit l’utilisation de la mémoire en partageant les données communes à de nombreux objets similaires. Il sépare l’état intrinsèque, qui appartient à l’objet partagé, de l’état extrinsèque, qui varie selon l’usage et est stocké ailleurs. Une fabrique peut réutiliser un poids mouche existant au lieu d’en créer des copies redondantes.

modèle publication/abonnement

messages transmis par un canal d’événements

Un modèle de communication dans lequel les éditeurs annoncent des événements sur un sujet ou un canal, et les abonnés indiquent leur intérêt pour ces événements. Le canal sépare les émetteurs des destinataires, de sorte que chaque partie peut fonctionner sans référence directe à l’autre. On peut généralement retirer les abonnés lorsqu’ils n’ont plus besoin de notifications.

modèle Médiateur

coordinateur central des interactions

Un modèle comportemental qui confie à un objet central la responsabilité de coordonner les interactions entre d’autres objets. Contrairement à un simple agrégateur d’événements, un médiateur prend en charge les décisions relatives au flux de travail : il détermine quels objets doivent agir et à quel moment, en fonction d’événements ou de conditions connus.

composant d’ordre supérieur (Higher-Order Component)

composant qui enveloppe un autre composant

Un modèle React dans lequel une fonction reçoit un composant et renvoie un nouveau composant doté de comportements ou de données supplémentaires. Il permet de réutiliser une logique, par exemple le chargement de données ou l’application d’un style commun. Toutefois, l’imbrication de composants enveloppants peut rendre plus difficile le suivi de l’origine des props et de la structure des composants.

modèle PRPL

livraison priorisée des ressources Web

Une approche de la performance Web fondée sur la transmission des ressources critiques, le rendu rapide de la route initiale, la précache des ressources susceptibles d’être nécessaires lors de visites ultérieures et le chargement différé des routes ou ressources moins fréquemment utilisées. Son objectif est d’afficher rapidement la première vue utile tout en préparant efficacement la navigation ultérieure.

architecture en îlots (Islands architecture)

zones interactives indépendantes d’une page

Une approche de rendu qui livre une page principalement sous forme de HTML statique, avec des composants interactifs distincts — les îlots — hydratés indépendamment. Chaque îlot peut embarquer le code côté client dont il a besoin, ce qui réduit la quantité de JavaScript nécessaire pour les contenus qui ne requièrent pas d’interaction. Cette approche convient mieux aux pages riches en contenu qu’aux applications fortement interconnectées.

FAQ

De quoi parle Apprendre les modèles de conception JavaScript, 2e édition ?

  • Un ouvrage consacré aux modèles de conception : Le livre propose un guide complet pour appliquer les modèles de conception en JavaScript, en particulier dans les applications Web modernes.
  • Un contexte moderne : Il présente plus de 20 modèles de conception, notamment des modèles classiques et des adaptations modernes pour des frameworks comme React, Vue et Angular.
  • Les bonnes pratiques : Il met l’accent sur les bonnes pratiques d’organisation du code, de performance et de maintenabilité, ce qui le rend utile aux développeurs de tous niveaux.

Pourquoi lire Apprendre les modèles de conception JavaScript, 2e édition ?

  • Améliorer la qualité du code : Comprendre les modèles de conception aide à écrire un code plus propre et plus facile à maintenir, que les autres développeurs peuvent comprendre plus facilement.
  • Rester à jour : Le livre tient compte des dernières avancées de JavaScript, notamment des fonctionnalités ES2015+, afin de vous familiariser avec les pratiques modernes.
  • Des exemples pratiques : Il comprend des exemples concrets et des applications des modèles de conception, facilitant leur mise en œuvre dans le monde réel.

Quels sont les principaux enseignements de Apprendre les modèles de conception JavaScript, 2e édition ?

  • Comprendre les modèles : Acquérir une compréhension approfondie de divers modèles de conception et de leur application efficace en JavaScript.
  • Optimiser les performances : Le livre aborde des modèles de performance comme la division du code et le rendu côté serveur, essentiels aux applications Web modernes.
  • Des modèles propres aux frameworks : Il couvre des modèles React comme les Hooks et les composants d’ordre supérieur, et présente les bonnes pratiques propres aux frameworks populaires.

Comment Apprendre les modèles de conception JavaScript, 2e édition traite-t-il des fonctionnalités modernes de JavaScript ?

  • La syntaxe ES2015+ : Le livre utilise la syntaxe et les fonctionnalités modernes de JavaScript, comme les classes, les modules et les fonctions fléchées, pour illustrer les modèles de conception.
  • Async/await : Il aborde les modèles de programmation asynchrone fondés sur async/await, qui facilitent la gestion claire des opérations asynchrones.
  • Amélioration des performances : Il montre comment les fonctionnalités modernes peuvent optimiser les performances et améliorer l’organisation du code dans les applications Web.

Quels sont les modèles de conception importants abordés dans Apprendre les modèles de conception JavaScript, 2e édition ?

  • Modèle Module : Il organise le code en modules réutilisables, favorisant l’encapsulation et la séparation des responsabilités.
  • Modèle Observateur : Il permet aux objets de s’abonner à des événements et d’être avertis des changements, facilitant une architecture faiblement couplée.
  • Modèle Singleton : Il limite l’instanciation d’une classe à une seule instance, ce qui est utile pour gérer des ressources partagées.

Pouvez-vous expliquer le modèle Module tel qu’il est présenté dans Apprendre les modèles de conception JavaScript, 2e édition ?

  • Encapsulation : Il encapsule les variables et les fonctions privées et n’expose que l’API publique, ce qui contribue à éviter la pollution de l’espace de noms global.
  • Utilisation des IIFE : Il utilise souvent des expressions de fonction immédiatement invoquées (IIFE) pour créer une portée privée pour les variables et les méthodes.
  • Réutilisabilité : Il organise le code en modules, permettant aux développeurs de créer des composants réutilisables, faciles à maintenir et à tester.

Quelle est l’importance du modèle Observateur dans Apprendre les modèles de conception JavaScript, 2e édition ?

  • Communication faiblement couplée : Il permet aux objets de communiquer sans être étroitement liés et de réagir aux changements.
  • Applications concrètes : Le livre donne des exemples d’application du modèle Observateur dans des frameworks modernes, ce qui améliore la réactivité des applications.
  • Architecture événementielle : Il souligne l’importance de l’architecture événementielle en JavaScript, essentielle à la création d’applications Web interactives.

Comment Apprendre les modèles de conception JavaScript, 2e édition aborde-t-il les modèles de programmation asynchrone ?

  • Modèles fondés sur les promesses : Le livre présente différents modèles de promesses, notamment le chaînage, l’exécution parallèle et la gestion des erreurs, afin de gérer efficacement les opérations asynchrones.
  • Async/await : Il présente async/await comme une manière moderne de gérer le code asynchrone, plus facile à lire et à maintenir.
  • Exemples pratiques : Il propose des exemples concrets montrant comment mettre en œuvre ces modèles dans des applications du monde réel, pour en faciliter la compréhension.

Que sont les composants d’ordre supérieur (HOC) dans React, tels qu’ils sont présentés dans Apprendre les modèles de conception JavaScript, 2e édition ?

  • Logique réutilisable : Les HOC sont des fonctions qui prennent un composant et renvoient un nouveau composant doté de props ou de comportements supplémentaires, favorisant la réutilisation de la logique.
  • Exemples d’utilisation : Le livre présente des exemples de HOC qui ajoutent aux composants des fonctionnalités comme des indicateurs de chargement ou des styles, afin d’enrichir leurs capacités.
  • Avantages et inconvénients : Les HOC favorisent la réutilisation du code, mais leur utilisation excessive peut entraîner une « jungle d’enveloppeurs » et complexifier l’arbre des composants.

Qu’est-ce que le modèle Render Props dans React ?

  • Une fonction comme prop : Il consiste à passer une fonction en prop à un composant ; cette fonction renvoie un élément React et permet une logique de rendu flexible.
  • Exemple de mise en œuvre : Le livre montre comment mettre en œuvre le modèle Render Props pour partager des données entre composants, par exemple à l’aide d’un convertisseur de température.
  • Comparaison avec les HOC : Par rapport aux HOC, Render Props évite les collisions de noms de props et rend le flux de données plus explicite, ce qui simplifie le débogage.

Comment Apprendre les modèles de conception JavaScript, 2e édition aborde-t-il la structure des applications React ?

  • Organisation des dossiers : Le livre examine différentes façons d’organiser les fichiers d’une application React, par exemple en les regroupant par fonctionnalité ou par type de fichier.
  • Structures hybrides : Il préconise des structures hybrides qui combinent les avantages des deux méthodes de regroupement, ce qui est essentiel pour les applications de grande envergure.
  • Bonnes pratiques : Il présente les bonnes pratiques pour structurer les applications React, notamment l’utilisation de Redux, des Hooks et de Styled Components.

Quels sont les modèles avancés abordés dans Apprendre les modèles de conception JavaScript, 2e édition ?

  • Architecture en îlots : Elle consiste à créer des îlots d’interactivité isolés au sein de pages statiques, ce qui permet de charger efficacement les composants dynamiques.
  • Hydratation progressive : Elle consiste à hydrater progressivement les composants en fonction des interactions de l’utilisateur, optimisant les performances en réduisant la charge JavaScript initiale.
  • SSR en flux : Cette méthode consiste à envoyer le HTML au client par petits fragments, ce qui améliore le délai avant le premier affichage et l’expérience utilisateur.

À propos de l'auteur

Addy Osmani est Senior Staff Engineering Manager chez Google Chrome, où il dirige des équipes qui se consacrent à améliorer l’efficacité du développement Web. Il a écrit plusieurs livres et intervient fréquemment lors de conférences internationales. Le travail d’Osmani vise à rendre le Web plus rapide et plus facile à développer. Son expertise en JavaScript et en technologies Web en a fait une figure respectée de la communauté des développeurs. Par ses écrits et ses interventions, Osmani partage ses connaissances et ses réflexions, contribuant ainsi aux progrès des pratiques et des techniques de développement Web.

Télécharger le PDF

Pour garder le résumé de Apprendre les modèles de conception JavaScript, 2e édition 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 Apprendre les modèles de conception JavaScript, 2e édition 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...