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
Developing Backbone.js Applications

Developing Backbone.js Applications

Structurez une application JavaScript en pleine croissance sans perdre la flexibilité qui faisait sa simplicité.
par Addy Osmani 2012 371 pages
3.70
188 é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

Remplacez les enchevêtrements de callbacks par des modèles, vues, collections et événements explicites.

Le code client finit par montrer les dents. Une page qui récupère des données, modifie le DOM et gère les entrées utilisateur au moyen de callbacks jQuery dispersés peut devenir difficile à faire évoluer. Chaque nouvelle fonctionnalité multiplie les endroits où l’interface, les règles métier et les données du serveur doivent rester synchronisées. Backbone apporte une structure à cette complexité sans imposer un framework volumineux ni une architecture personnalisée à bâtir de toutes pièces.

Adoptez une structure lorsqu’elle est utile. L’exemple récurrent du livre est une application de tâches: les utilisateurs ajoutent, modifient, terminent, filtrent et suppriment des éléments sans recharger la page. Ces actions rendent l’application suffisamment riche pour tirer parti de composants explicites. Pour un site essentiellement généré côté serveur, avec seulement quelques interactions, le même dispositif peut être superflu.

Analyse

Le meilleur argument en faveur de Backbone n’est pas que chaque interaction dans le navigateur a besoin d’un framework. C’est que la complexité doit devenir visible avant de s’emmêler. Nommer les couches de données, d’interface et de coordination donne aux équipes une carte commune pour le débogage et la revue de code. Cela rappelle la conception modulaire dans d’autres domaines de l’ingénierie : des frontières facilitent la localisation des changements. Il existe toutefois un véritable contrepoids. L’abstraction a aussi un coût, et une petite interaction peut devenir moins claire si on l’enveloppe de conventions de framework dont elle n’a pas besoin.

Utilisez Backbone comme boîte à outils MV* souple, et non comme une implémentation scolaire de MVC.

L’appellation est approximative. Le modèle-vue-contrôleur classique sépare les données du domaine, la présentation et un contrôleur qui interprète les entrées utilisateur. Backbone fournit des modèles, des vues, des collections et des routeurs, mais pas de classe Contrôleur distincte. Les gestionnaires d’événements des vues assument souvent des fonctions de contrôleur, tandis que les routeurs associent les URL au comportement de l’application. Le livre présente donc Backbone comme une architecture MV, une architecture modèle-vue dont la répartition des responsabilités est propre au framework.

Repérez les véritables frontières. Dans une vue de tâches, un gestionnaire de clic peut mettre à jour un modèle, lequel peut signaler le changement pour que l’interface réagisse. Cette organisation diffère d’une architecture MVC classique stricte, mais sépare tout de même les données de la présentation et aide à déterminer quoi tester.

Analyse

L’intérêt, ici, est de distinguer l’objectif d’un modèle de son appellation. MVC n’est pas un schéma universel dont les composants apparaissent de façon identique dans chaque framework. Prendre son nom pour une garantie peut pousser les développeurs à chercher un contrôleur inexistant ou à placer de force la logique dans la mauvaise couche. La mise en garde du livre s’applique largement : décrire les responsabilités réellement présentes dans une base de code, puis déterminer si elles sont suffisamment séparées. Le vocabulaire architectural n’éclaire que lorsqu’il correspond à l’implémentation.

Conservez les données dans les modèles, les listes dans les collections et le rendu dans les vues.

Attribuez une fonction à chaque composant. Un modèle Backbone contient les attributs d’une entité et le comportement associé. Sa méthode `set()` met à jour les valeurs et émet des événements de changement, tandis que `validate()` peut rejeter un état invalide. Une collection regroupe des modèles, prend en charge des opérations telles que le filtrage et le tri, et relaie les événements utiles lorsque ses membres changent. Une vue gère le comportement de présentation; elle affiche généralement les données d’un modèle au moyen d’un gabarit dans un élément du DOM.

Suivez le cheminement d’un changement. Dans l’exemple de l’application de tâches, une case à cocher appelle une méthode du modèle qui inverse l’état d’achèvement et enregistre la nouvelle valeur. Le modèle émet une notification de changement, la vue correspondante se redessine, et la collection ou la vue de l’application peut actualiser les compteurs. Les gabarits séparent le balisage du JavaScript qui fournit les données.

Analyse

Cette répartition instaure une séparation des préoccupations concrète, sans pour autant exiger une classe par champ ou une vue par fragment visuel. La conception est utile lorsqu’elle rend compréhensible la propagation des changements : une action de l’utilisateur modifie l’état, et l’interface découle de cet état. Cela rejoint la logique du flux de données unidirectionnel, même si Backbone n’impose pas un tel système. Les équipes doivent toujours décider quel composant est responsable d’une règle, surtout lorsqu’une vue commence à accumuler des décisions métier.

Considérez les abonnements aux événements comme des ressources liées au cycle de vie, et non comme de simples callbacks inoffensifs.

Les événements réduisent le couplage. Au lieu qu’un composant en appelle directement un autre, le système d’événements de Backbone permet aux objets de publier et d’observer des changements nommés. Une vue peut écouter l’événement de changement d’un modèle et se redessiner sans que le modèle sache comment la vue fonctionne. Les collections peuvent faire remonter les changements de leurs modèles, et des événements personnalisés peuvent relier des parties autrement indépendantes d’une application.

N’oubliez pas de vous désabonner. Un modèle qui survit à une vue peut conserver un callback pointant vers cette vue, la maintenant en mémoire et provoquant sa réaction alors qu’elle aurait dû disparaître. La méthode `listenTo()` de Backbone enregistre les abonnements auprès de l’objet à l’écoute, ce qui permet à `stopListening()` de les supprimer tous à la fois. Le processus de suppression par défaut d’une vue nettoie les abonnements établis de cette manière.

Analyse

Il s’agit d’une version logicielle de la gestion des ressources : ouvrir un fichier, enregistrer un écouteur ou créer une vue entraîne l’obligation de libérer la ressource. Le modèle événementiel est puissant précisément parce qu’il masque les chaînes d’appels directs, mais cette souplesse peut aussi dissimuler les dépendances et rendre l’exécution plus difficile à suivre. Une bonne discipline consiste à considérer les abonnements comme une partie du cycle de vie d’un objet, et non comme une simple étape de configuration. Un nettoyage explicite et des événements bien nommés préservent les avantages du découplage sans laisser de connexions invisibles.

Laissez Backbone.sync traduire les opérations sur les modèles en un contrat serveur clair.

La persistance suit l’intention du modèle. Les méthodes `fetch()`, `save()` et `destroy()` de Backbone délèguent à `Backbone.sync`, qui associe les lectures, créations, mises à jour, mises à jour partielles et suppressions aux requêtes HTTP. Un nouveau modèle est généralement envoyé avec POST; un modèle existant est mis à jour avec PUT, ou avec PATCH si seuls les attributs modifiés doivent être envoyés; la suppression utilise DELETE. Les collections peuvent récupérer un ensemble de modèles depuis leur URL.

Adaptez-vous précisément à l’API. L’exercice du livre consacré à une bibliothèque relie une application de navigateur à une API REST adossée à MongoDB. Il montre comment des identifiants incompatibles peuvent compromettre la persistance: Backbone attend par défaut un `id`, tandis que MongoDB renvoie ` id`. Définir `idAttribute` ou convertir la réponse dans `parse()` permet à Backbone de reconnaître correctement les enregistrements sauvegardés.

Analyse

La couche sync constitue une frontière d’adaptation : le code de l’application peut exprimer une opération sur un modèle, tandis que l’implémentation de synchronisation gère les détails du transport. Cette frontière aide à isoler les changements du serveur et peut prendre en charge d’autres solutions, comme le stockage dans le navigateur. Mais une convention ne remplace pas un accord sur l’API. Le format des identifiants, la représentation des dates, la validation et la gestion des erreurs restent des décisions contractuelles. La bibliothèque peut simplifier les échanges, mais elle ne peut pas faire s’entendre deux systèmes sur le sens de leurs données.

Ajoutez Marionette lorsque le cycle de vie des vues et le code répétitif de rendu nuisent à la clarté.

N’étendez que si nécessaire. Backbone laisse volontairement de nombreuses décisions relatives à l’application aux développeurs. Marionette ajoute des types de vues réutilisables, le rendu automatique des gabarits, des régions où afficher les vues et des mécanismes de nettoyage. Son `ItemView` peut remplacer le code répétitif de compilation des gabarits et de rendu. Une `Region` gère un emplacement précis du DOM: elle affiche la vue entrante et ferme celle qui s’y trouve lorsque l’on en affiche une autre.

Composez des écrans complexes. La `CompositeView` de Marionette peut afficher une collection et ses éléments individuels, y compris des hiérarchies récursives. Le livre refactorise l’application de tâches au moyen de régions, de mises en page et d’une coordination des flux de travail similaire à celle d’un contrôleur. Il ne s’agit pas d’affirmer que chaque projet a besoin de cette extension, mais de montrer que les équipes peuvent en adopter certains composants sans devoir tout prendre ou tout laisser.

Analyse

Les extensions sont les plus efficaces lorsqu’elles encodent une solution récurrente que l’équipe comprend déjà. La gestion du cycle de vie proposée par Marionette est particulièrement utile, car les fuites de vues et la répétition du code de rendu sont des problèmes opérationnels, et pas seulement des questions de style. Toutefois, un framework plus riche introduit aussi davantage de concepts et de conventions que les personnes chargées de la maintenance doivent apprendre. La décision doit reposer sur la fréquence et le coût du problème à résoudre. L’abstraction est avantageuse lorsqu’elle supprime les répétitions tout en rendant le cycle de vie plus lisible, et non lorsqu’elle ne fait que raccourcir les fichiers.

Déclarez les dépendances des modules au lieu de vous fier à l’ordre des balises de script.

Rendez les dépendances explicites. AMD, ou Asynchronous Module Definition, permet à chaque module JavaScript de déclarer ce dont il a besoin et ce qu’il fournit. RequireJS charge ces dépendances, évitant ainsi une chaîne fragile de balises de script dont l’ordre doit être géré manuellement. Le chargement asynchrone peut éviter que le navigateur attende le chargement de chaque script avant de poursuivre le rendu, et les modules peuvent être chargés uniquement au besoin.

Séparez le développement de la livraison. Le livre montre comment envelopper dans des modules les modèles, collections, vues et gabarits Backbone. Les shims de RequireJS facilitent le chargement de bibliothèques telles que Backbone, qui ne définissent pas elles-mêmes de modules AMD. L’optimiseur `r.js` peut regrouper et réduire les ressources de production tout en préservant les modules qui doivent être chargés dynamiquement. Les outils de génération de code peuvent créer l’arborescence des fichiers courants et les étapes de compilation.

Analyse

Des dépendances explicites améliorent bien plus que le chargement des pages. Elles rendent inspectables les hypothèses d’un module, ce qui facilite les tests, la réutilisation et la refactorisation. C’est une forme d’inversion des dépendances : un composant reçoit ce dont il a besoin au lieu de puiser dans un environnement global imprévisible. Le chargement asynchrone n’est pas automatiquement plus rapide dans tous les cas, car le surcroît de requêtes et le coût du chargeur peuvent annuler le gain. La distinction importante se situe entre un modèle de dépendances clair pendant le développement et une stratégie de livraison optimisée pour la production.

Testez le comportement à l’aide de fixtures isolées, de spies et de réponses simulées.

Testez la plus petite unité utile. Jasmine et QUnit permettent aux développeurs de vérifier les valeurs par défaut des modèles, la validation, le comportement des collections, le rendu des vues et les interactions de l’application. Les deux frameworks prennent en charge la préparation et le nettoyage afin que les tests démarrent dans des conditions connues. Les fixtures du DOM fournissent un balisage contrôlé pour tester les vues, tandis que les assertions vérifient que la sortie et l’état correspondent aux attentes.

Maîtrisez les comportements externes. Un serveur réel rend les tests plus lents et moins prévisibles. Les spies de Jasmine et de SinonJS peuvent enregistrer les appels; les stubs remplacent un comportement; les mocks ajoutent des attentes quant à la façon dont une dépendance doit être utilisée. Ces outils permettent à un test de vérifier, par exemple, qu’une requête Ajax cible l’URL attendue et appelle le bon callback sans contacter un service en production.

Analyse

Le principal avantage réside dans la qualité du retour d’information. Un test qui isole une règle de modèle peut détecter une régression plus rapidement qu’une inspection manuelle de toute l’application. Les objets simulés rendent également reproductibles les réponses rares du serveur. Cependant, le nombre de tests ne garantit pas la justesse : une suite peut confirmer de façon fiable une spécification incomplète ou erronée. L’approche du livre, axée sur le développement piloté par les tests, répond à ce problème en écrivant les attentes avant l’implémentation ; ses exemples montrent aussi pourquoi les tests doivent viser un comportement significatif plutôt que le seul fonctionnement du framework.

Séparez le routage de Backbone du cycle d’enrichissement des pages de jQuery Mobile.

Évitez les navigateurs concurrents. Backbone gère les URL et les états de l’application; jQuery Mobile intercepte les liens, demande des pages et enrichit le balisage pour en faire des widgets. Si les deux frameworks contrôlent la navigation, leur gestion des événements et de l’historique peut entrer en conflit. L’intégration décrite dans le livre désactive le routage et l’enrichissement automatiques de jQuery Mobile, laisse Backbone choisir la page, puis appelle l’API de page de jQuery Mobile pour l’enrichir et l’afficher.

Enrichissez délibérément le balisage dynamique. Le nouveau contenu mobile inséré peut nécessiter un appel explicite à l’API d’enrichissement d’une page ou d’un widget. Reconstruire une page entière est simple, tandis que mettre à jour un seul composant peut être plus rapide, mais nécessite la méthode d’actualisation propre au widget concerné. Le livre avertit également que les transitions peuvent représenter une grande partie du temps de chargement sur certains appareils; il est donc important de profiler et d’adapter les choix aux appareils.

Analyse

Cette intégration illustre un principe général de composition : deux bibliothèques peuvent coexister si chacune assume une responsabilité clairement délimitée. La difficulté tient au fait qu’un changement de page visible par l’utilisateur ne constitue pas une opération unique. Le routage, l’insertion dans le DOM, l’initialisation des widgets, l’historique et l’animation ont chacun leur propre état et leur propre temporalité. Les traiter comme un seul événement ouvre la porte à des bogues subtils. Le compromis est la complexité : une coordination personnalisée offre du contrôle, mais oblige aussi les développeurs à comprendre le cycle de vie des deux frameworks plutôt que de s’en remettre à l’un ou à l’autre.

Choisissez la pagination côté serveur ou côté client selon l’emplacement des données.

La pagination peut se faire à deux endroits. Backbone.Paginator distingue `requestPager`, qui demande une page précise au serveur, de `clientPager`, qui divise un jeu de données déjà chargé dans le navigateur. La pagination par requête limite la taille de chaque réponse réseau et convient aux API qui fournissent des résultats paginés. La pagination côté client évite une requête supplémentaire lorsque les utilisateurs passent d’une page à l’autre, mais suppose que le jeu de données pertinent soit disponible localement.

Laissez le contexte guider votre choix. Une API de recherche proposant des milliers de résultats peut renvoyer un petit sous-ensemble à chaque requête, les paramètres de tri et de recherche étant transmis au serveur. En revanche, une réponse modeste déjà récupérée dans son intégralité peut être répartie en pages plus petites à afficher dans l’interface. Le chargement infini est une autre forme de pagination par requête: récupérer le lot suivant et l’ajouter aux résultats existants au lieu de les remplacer.

Analyse

La distinction porte essentiellement sur l’endroit où s’effectuent les calculs et les transferts de données. La pagination côté serveur économise la mémoire du client et limite les transferts, mais les changements de page répétés dépendent de l’accès réseau et de la conception de l’API. La pagination côté client rend le tri et le filtrage locaux réactifs, mais peut gaspiller de la bande passante si la plupart des enregistrements récupérés ne sont jamais consultés. Aucune méthode n’est intrinsèquement supérieure. Le bon choix dépend de la taille du jeu de données, des habitudes d’interaction et des capacités du service ; c’est pourquoi le chapitre sur la pagination traite la conception comme un problème propre au contenu, plutôt que comme le choix d’un simple widget visuel.

Analyse

Ce livre est à la fois un tutoriel de programmation et un tour d’horizon des choix architecturaux. Son récit part d’un problème familier: une interface JavaScript accumule peu à peu des callbacks qui synchronisent les données, le HTML et les requêtes au serveur. Backbone est présenté comme une couche d’organisation légère, et non comme une machine qui élimine les décisions de conception. Les modèles, collections, vues, événements et routeurs offrent des emplacements bien définis où prendre ces décisions. Les exercices pratiques rendent l’argument concret, d’abord avec une liste de tâches enregistrée dans le navigateur, puis avec une bibliothèque de livres connectée à une API REST.

L’apport le plus durable du livre tient à l’importance accordée aux responsabilités et au cycle de vie. Un changement de modèle doit pouvoir être observé; une vue doit pouvoir être supprimée; la représentation d’une donnée sur le serveur doit correspondre de façon fiable à son identité côté client. Ces détails transforment l’architecture, d’un diagramme, en comportements vérifiables par des tests. Les chapitres sur Marionette, RequireJS, la pagination et jQuery Mobile prolongent la même préoccupation à des systèmes plus vastes: réduire le travail répétitif, rendre les dépendances visibles et empêcher des gestionnaires de cycle de vie concurrents de se gêner.

Le livre évite aussi de présenter MVC comme une identité stricte. La vue de Backbone assume des fonctions de gestion des événements, et le routeur gère l’état des URL; MV est donc une description plus juste que le MVC scolaire. Cette précision compte, car les noms influencent l’implémentation. La discussion sur les agrégateurs d’événements et les médiateurs montre également que des mécanismes identiques peuvent répondre à des intentions différentes.

Sa principale limite est d’ordre temporel. Les exemples décrivent l’écosystème JavaScript de 2012 à 2013, avec des versions précises de bibliothèques et d’outils qu’il ne faut pas supposer représentatives des pratiques actuelles. Leurs API appartiennent à l’histoire; leurs questions de conception restent familières. Le minimalisme de Backbone reporte la responsabilité sur les développeurs, ce qui offre de la liberté aux équipes expérimentées, mais peut conduire à une architecture incohérente dans d’autres équipes. La leçon pratique n’est pas d’adopter chaque outil nommé, mais de déterminer où doivent se trouver l’état, le rendu, la navigation, la persistance et le nettoyage, puis de choisir la structure la plus légère qui rende ces responsabilités lisibles.

Résumé en 30 secondes
Les modèles contiennent les données et les règles de validation, les collections gèrent des groupes de modèles et les vues affichent les changements dans l’interface. Les événements relient les composants, mais les abonnements doivent être nettoyés lors de la suppression des vues pour éviter les fuites et les comportements obsolètes. Backbone associe les opérations sur les modèles aux requêtes HTTP, tandis que les identifiants de l’API doivent correspondre aux attentes du client. Des modules explicites, des tests isolés avec des espions et de fausses réponses, ainsi qu’un choix réfléchi entre pagination côté serveur et côté client, aident à maîtriser les applications de plus grande ampleur.
Contient des spoilers

Dernière mise à jour:

Signaler un problème

Résumé des avis

3.70 sur 5
Moyenne de 188 évaluations de Goodreads et Amazon.

Developing Backbone.js Applications reçoit des avis partagés, avec une note moyenne de 3,69 sur 5. Les lecteurs apprécient sa couverture approfondie de Backbone.js et des technologies associées, et saluent la progression logique ainsi que la qualité des exemples. Toutefois, certains estiment que le livre s’adresse davantage à un public de niveau intermédiaire ou avancé qu’aux débutants. Les critiques signalent un contenu daté, des exemples de code incomplets et un manque d’explications approfondies. Malgré ces réserves, beaucoup le considèrent toujours comme une ressource utile pour apprendre Backbone.js, surtout si l’on complète sa lecture par de la pratique et de la documentation supplémentaire.

Votre note :
4.23
159 évaluations
Envie de lire le livre complet ?

Les lecteurs ont aussi lu

Glossaire

MV*

Architecture de modèles et de vues

Abréviation désignant les architectures d’applications JavaScript construites autour de modèles et de vues, sans imposer de contrôleur distinct ni une interprétation précise de MVC. Backbone correspond à cette description, car ses vues gèrent souvent les événements utilisateur, tandis que les routeurs coordonnent l’état de l’application associé aux URL.

Backbone.Events

Système d’événements pour objets

Utilitaire de publication et d’abonnement de Backbone, intégré aux modèles, collections, vues, routeurs et autres objets. Les objets peuvent enregistrer des fonctions de rappel avec on() ou listenTo(), publier des notifications avec trigger() et supprimer des abonnements avec off() ou stopListening(). Il permet aux composants de communiquer sans appels directs de méthodes.

listenTo()

Abonnement aux événements suivi

Méthode d’événement de Backbone qui permet à un objet de s’abonner aux événements d’un autre tout en enregistrant cette relation sur l’objet qui écoute. Contrairement à un abonnement simple effectué avec on(), elle facilite le nettoyage : l’objet qui écoute peut appeler stopListening() pour supprimer certains de ses abonnements ou tous. Les vues Backbone l’utilisent pour éviter les fonctions de rappel obsolètes et les fuites de mémoire.

vue fantôme

Vue supprimée qui écoute encore

Vue dont l’interface n’a plus besoin, mais qui reste accessible parce qu’un modèle ou un autre objet à la durée de vie plus longue conserve une référence à l’une de ses fonctions de rappel d’événement. La vue peut continuer à réagir aux événements et ne peut pas être libérée de la mémoire. L’utilisation d’abonnements suivis et leur arrêt lors de la suppression de la vue évitent ce problème.

Backbone.sync

Adaptateur de persistance

Fonction appelée par Backbone pour assurer la persistance des modèles et des collections. Son implémentation par défaut associe les opérations de création, lecture, mise à jour, mise à jour partielle et suppression à des méthodes HTTP, puis envoie les requêtes au moyen d’une méthode Ajax compatible avec jQuery. Les développeurs peuvent la remplacer pour connecter Backbone à une autre API ou à un autre mécanisme de stockage.

AMD

Définition asynchrone de modules

Format de modules JavaScript dans lequel le code déclare ses dépendances et expose une valeur de module. RequireJS implémente AMD en chargeant les modules et en transmettant leurs dépendances à une fonction fabrique. Ce format aide à éviter les dépendances implicites aux variables globales et aux balises de script dont l’ordre doit être défini manuellement, et peut prendre en charge le chargement asynchrone ou à la demande.

Marionette.Region

Gestionnaire du cycle de vie des vues

Objet Marionette chargé de gérer les vues affichées dans un élément DOM donné. Lorsqu’on lui fournit une vue, une région la rend et insère son élément. Lorsqu’une autre vue la remplace, la région ferme ou supprime l’ancienne vue, ce qui contribue à centraliser les responsabilités d’affichage et de nettoyage.

CompositeView

Vue hiérarchique de collection

Vue Marionette conçue pour afficher une collection et ses éléments dans une même structure composite. Elle peut utiliser une vue d’élément définie pour chaque modèle et prendre en charge l’affichage récursif de collections imbriquées. Elle réduit ainsi le code personnalisé nécessaire à la présentation de données hiérarchiques.

Backbone.Paginator.requestPager

Pagination côté serveur des collections

Composant Backbone.Paginator destiné aux collections dont la source de données prend en charge la pagination. Il construit des requêtes pour les pages choisies et propose des méthodes de navigation, comme passer à la page suivante ou à une page donnée. Il est utile lorsqu’un client ne doit demander qu’un sous-ensemble d’un ensemble de résultats plus vaste stocké sur le serveur.

Backbone.Paginator.clientPager

Pagination en mémoire des collections

Composant Backbone.Paginator qui répartit en pages, pour leur affichage, les données déjà chargées dans le navigateur. Il peut prendre en charge la navigation locale entre les pages, le tri et le filtrage sans nouvelle requête à chaque page. Cette approche suppose que l’ensemble de données concerné a déjà été récupéré et est disponible côté client.

FAQ

1. De quoi parle « Developing Backbone.js Applications » d’Addy Osmani ?

  • Un guide complet de Backbone.js : Le livre propose une introduction approfondie à Backbone.js, un framework JavaScript léger destiné à structurer les applications Web côté client.
  • Les concepts fondamentaux : Il explique les modèles, les vues, les collections, les routeurs et la manière de créer des applications monopages (SPA) modulaires et faciles à maintenir.
  • Un apprentissage pratique : Les lecteurs sont guidés à travers des projets concrets, comme une application de gestion de tâches et une application de bibliothèque, au moyen d’exercices étape par étape et d’exemples tirés de situations réelles.
  • Des sujets avancés : Le livre aborde également le développement modulaire, l’intégration RESTful, les tests, l’optimisation et les extensions populaires de Backbone.

2. Pourquoi lire « Developing Backbone.js Applications » d’Addy Osmani ?

  • Améliorer l’architecture côté client : Le livre montre comment Backbone.js aide à organiser les applications complexes riches en JavaScript, pour rendre le code plus facile à maintenir et à faire évoluer.
  • Acquérir des compétences pratiques : À l’aide d’exemples et d’exercices détaillés, les lecteurs apprennent à créer, tester et optimiser des applications réelles avec Backbone et les outils associés.
  • Aborder les défis courants et avancés : Le livre traite de problèmes comme la modularisation, la gestion de la mémoire et l’intégration avec d’autres bibliothèques, en proposant des solutions aux pièges courants de Backbone.js.
  • Une ressource libre et participative : Publié sous licence Creative Commons, le livre encourage les contributions de la communauté et est accessible aux développeurs débutants et intermédiaires.

3. Quels sont les principaux enseignements de « Developing Backbone.js Applications » d’Addy Osmani ?

  • Une architecture minimaliste et flexible : Backbone.js fournit juste la structure nécessaire — modèles, collections, vues et routeurs — sans imposer de schémas rigides, ce qui permet aux développeurs de l’adapter à leurs besoins.
  • Une approche événementielle et RESTful : Le système d’événements du framework maintient les données et l’interface utilisateur en phase, et il s’intègre facilement aux API RESTful pour communiquer avec le serveur.
  • Un développement modulaire et évolutif : Le livre met l’accent sur l’organisation modulaire du code au moyen d’AMD et de RequireJS, afin de rendre les grandes applications faciles à maintenir et efficaces.
  • Tests et optimisation : Les lecteurs découvrent les bonnes pratiques de test avec Jasmine et QUnit ainsi que l’optimisation des versions de production à l’aide d’outils comme r.js.

4. Quelles sont les meilleures citations de « Developing Backbone.js Applications » et que signifient-elles ?

  • Un ensemble minimal de primitives : « Le principe fondamental qui a toujours guidé Backbone est de chercher à découvrir l’ensemble minimal de primitives de structuration des données (modèles et collections) et de l’interface utilisateur (vues et URL) utiles à la création d’applications Web en JavaScript. » Cette citation souligne la philosophie de simplicité et de juste suffisance de Backbone.
  • Accueillir de nouvelles perspectives : « La destination n’est jamais un lieu, mais une nouvelle manière de voir les choses. » — Henry Miller. Cette citation invite les développeurs à adopter de nouvelles approches, comme Backbone, pour améliorer leur pratique.
  • L’importance des espaces de noms : « En l’absence de conventions solides en matière d’espaces de noms, il est également assez facile de polluer l’espace de noms global avec ses propres objets personnalisés. » Cela souligne l’importance de la modularité et d’une organisation claire du code en JavaScript.

5. Comment « Developing Backbone.js Applications » d’Addy Osmani explique-t-il le modèle MVC et l’approche MV* de Backbone ?

  • Explication des bases de MVC : Le livre décrit MVC comme une séparation des responsabilités entre les modèles (données), les vues (interface utilisateur) et les contrôleurs (gestion des entrées), avec une communication claire entre les composants.
  • La variante MV de Backbone :* Backbone intègre les responsabilités du contrôleur aux vues et utilise des routeurs pour la navigation ; il relève donc d’une architecture MV* plutôt que d’un framework strictement MVC.
  • Mises à jour événementielles : Les modèles et les vues communiquent par l’intermédiaire d’un système d’événements, ce qui maintient les données et l’interface synchronisées sans couplage direct.
  • Modèles et routage : Les vues affichent des modèles (comme Underscore ou Handlebars), et les routeurs gèrent l’état et la navigation des applications monopages.

6. Comment fonctionnent les modèles, les vues, les collections et les routeurs de Backbone.js d’après le livre d’Addy Osmani ?

  • Modèles : Ils contiennent les attributs de données, prennent en charge les valeurs par défaut et la validation, et peuvent enregistrer les données sur un serveur à l’aide de méthodes RESTful comme save(), fetch() et destroy().
  • Vues : Elles gèrent la logique de l’interface utilisateur, affichent les modèles et prennent en charge de manière déclarative les événements DOM ; elles écoutent les changements des modèles pour mettre à jour l’interface.
  • Collections : Ensembles ordonnés de modèles dotés de méthodes utilitaires permettant d’ajouter, de supprimer, de filtrer et de trier des éléments ; elles peuvent également récupérer des données depuis des serveurs.
  • Routeurs : Ils associent des fragments d’URL à des fonctions, ce qui permet de mettre en favori des états et d’assurer la navigation dans les applications monopages.

7. Quelles sont les principales caractéristiques et les avantages de Backbone.js mis en avant dans « Developing Backbone.js Applications » ?

  • Léger et flexible : Backbone fournit une structure minimale qui laisse aux développeurs la liberté de créer leurs applications selon leur style préféré.
  • Événementiel et RESTful : Il offre une gestion riche des événements entre les modèles et les vues, ainsi qu’une intégration fluide aux API RESTful pour la persistance des données.
  • Modulaire et évolutif : Il convient aussi bien aux petits composants qu’aux grandes applications et fonctionne bien avec d’autres bibliothèques et frameworks.
  • Lisible et efficace : Le code source est concis et accessible, ce qui le rend facile à comprendre et à étendre pour les développeurs.

8. Comment le livre d’Addy Osmani explique-t-il la création d’une application de gestion de tâches avec Backbone.js ?

  • Une architecture expliquée étape par étape : Le livre guide le lecteur dans la création des modèles, des collections et des vues de tâches, et montre les opérations CRUD ainsi que la liaison à l’interface utilisateur.
  • Modèles et événements : Il utilise des modèles Underscore.js pour le rendu et une gestion déclarative des événements pour les interactions comme l’ajout, la modification et la suppression de tâches.
  • Persistance avec localStorage : Il montre comment utiliser Backbone.localStorage pour conserver les données dans le navigateur sans serveur.
  • Routage et filtrage : Il met en place le filtrage par URL (toutes, actives, terminées) à l’aide de Backbone.Router, afin de pouvoir mettre en favori différents états de l’application.

9. Comment « Developing Backbone.js Applications » d’Addy Osmani recommande-t-il d’intégrer Backbone.js à un système dorsal RESTful ?

  • Séparation des responsabilités : L’application Backbone côté client communique avec une API REST Node.js/Express côté serveur, illustrant les interactions client-serveur dans des conditions proches du réel.
  • Configuration des modèles et des collections : Les modèles et les collections sont configurés avec des URL pointant vers l’API REST, ce qui permet à fetch(), save() et destroy() de se synchroniser avec le serveur.
  • Gestion des données imbriquées : Le livre aborde des difficultés comme le formatage des dates et les attributs imbriqués, et montre comment analyser et sérialiser correctement les données.
  • Implémentation côté serveur : Il explique comment mettre en place une API REST s’appuyant sur MongoDB et dotée de routes CRUD, afin de connecter les applications Backbone à un stockage persistant.

10. Que sont MarionetteJS et Thorax, et comment étendent-ils Backbone.js selon le livre d’Addy Osmani ?

  • MarionetteJS : Bibliothèque pour applications composites qui réduit le code répétitif, gère la mémoire et le cycle de vie des vues, et fournit des types de vues spécialisés ainsi que des régions pour gérer la mise en page.
  • Réduction du code répétitif : Elle automatise la logique de rendu et le nettoyage des vues, évitant les fuites de mémoire et les vues zombies.
  • Thorax : Framework prescriptif construit sur Backbone, qui utilise les modèles Handlebars et propose des conventions d’organisation des applications et d’intégration des vues enfants.
  • Flexibilité et modularité : Ces deux extensions permettent aux développeurs de faire évoluer leurs applications Backbone grâce à une meilleure structure et une maintenance simplifiée, tout en s’intégrant harmonieusement au code existant.

11. Comment « Developing Backbone.js Applications » d’Addy Osmani recommande-t-il de modulariser les applications avec RequireJS et AMD ?

  • Chargement asynchrone des modules : RequireJS charge les fichiers JavaScript de manière asynchrone, ce qui améliore les performances et permet le chargement dynamique des modules.
  • Définition de modules AMD : Les modules sont définis avec define(), qui précise leurs dépendances et une fonction fabrique pour gérer proprement celles-ci.
  • Modèles externes et shims : Le livre utilise le plug-in text.js de RequireJS pour les modèles externes et configure des shims pour les bibliothèques non compatibles avec AMD, comme Backbone et Underscore.
  • Organisation du code : Il encourage à répartir les modèles, les vues, les collections et les routeurs dans des dossiers distincts et à encapsuler les composants sous forme de modules AMD pour faciliter la maintenance.

12. Comment le livre d’Addy Osmani aborde-t-il les tests des applications Backbone.js avec Jasmine, QUnit et SinonJS ?

  • Jasmine pour le développement piloté par le comportement (BDD) : Le livre présente Jasmine comme un framework de développement piloté par le comportement qui permet d’écrire des tests unitaires automatisés et lisibles à l’aide de suites, de spécifications et d’espions.
  • Tests des modèles, des collections et des vues : Il propose des exemples de tests portant sur les valeurs par défaut, la validation, le filtrage, le rendu et l’intégration au DOM, à l’aide de fixtures jasmine-jquery.
  • Prise en charge de l’asynchrone et des espions : Il montre comment simuler les requêtes AJAX et écrire des tests asynchrones pour vérifier rigoureusement les interactions entre le client et le serveur.
  • Comparaison avec QUnit et SinonJS : Il explique les assertions et les modules simples de QUnit, ainsi que les espions, stubs et mocks proposés par SinonJS pour examiner en détail les appels de fonctions.

À propos de l'auteur

Addy Osmani est directeur principal de l’ingénierie chez Google Chrome, où il dirige des équipes qui s’attachent à améliorer l’efficacité et les performances du développement Web. Il a écrit plusieurs livres et intervient régulièrement lors de conférences internationales. Addy Osmani se spécialise dans l’accélération et la démocratisation du développement Web pour les développeurs. Chez Google Chrome, son travail consiste à rationaliser le processus de développement Web et à renforcer les capacités de la plateforme. Fort de sa vaste expérience et de ses contributions au domaine, Osmani s’est imposé comme une figure respectée de la communauté du développement Web, reconnue pour ses analyses et ses approches pratiques des technologies Web modernes.

Télécharger le PDF

Pour garder le résumé de Developing Backbone.js Applications 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 Developing Backbone.js Applications 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
1M+ 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...