1. Livres et vidéos
  2. Angular et Node.js - Optimisez le développement de vos applications web avec une architecture MEAN (2e édition)

Angular et Node.js Optimisez le développement de vos applications web avec une architecture MEAN (2e édition)

  • En stock
  • Expédié en 24h00
  • Livraison à partir de 0,01 €
  • Version en ligne offerte pendant 1 an
  • 1 h d'accès gratuit à tous nos livres et vidéos pour chaque commande
  • Accessible immédiatement
  • Version HTML
  • Accès illimité 24h/24, 7J/7
  • Accès illimité 24h/24, 7J/7
  • Tous les livres en ligne, les vidéos et les cours enregistrés ENI
  • Plus de 10 nouveautés livres et vidéos chaque mois
  • Les nouveautés disponibles le jour de leur sortie
  • Accès 100% en ligne

Présentation

Ce livre s'adresse à tout informaticien qui souhaite optimiser le développement industriel de ses applications web avec la mise en place d'une architecture MEAN (basée sur MongoDB, le framework Express, le framework Angular et un serveur Node.js). L'auteur lui donne les clés pour répondre aux nouvelles exigences de plus en plus fortes de ce type de développement, à savoir le besoin de réutiliser des briques logicielles pour augmenter la productivité du développement et l'optimisation de la charge des serveurs qui ne cesse d'augmenter.

Le développement d'une application Angular au sein d'une architecture MEAN bénéficie de la cohérence de l'utilisation de JavaScript, et de son extension TypeScript, au niveau du client et du serveur. Dans les deux premiers chapitres, le lecteur trouvera ainsi les informations nécessaires pour comprendre ce langage permettant une programmation objet avec classes. Sont ensuite détaillés, d'une part la mise en œuvre d'un serveur Node.js extrêmement réactif, et d'autre part le framework applicatif Angular (en version 8 au moment de l’écriture). Celui-ci permet de créer des applications monopages (interagissant avec le serveur uniquement pour échanger des données) et fait preuve d'une modularité exemplaire organisée en deux niveaux : les modules et les composants. Le livre présente également le système de gestion de bases de données NoSQL MongoDB qui, associé aux deux autres piliers de l'architecture, permettra un accès performant à une très forte volumétrie de données.

La visualisation d'informations étant par ailleurs un domaine phare d'Angular, l'affichage de graphiques ainsi que l'annotation graphique de Google Maps sont également étudiés. Enfin, l'utilisation de trois bibliothèques de composants graphiques très populaires (PrimeNG, Material et ngx-bootstrap) est également introduite en fin d'ouvrage.

Tout au long du livre, un fil rouge avec de très nombreux exemples de code guide le lecteur vers la création d'une application de e-commerce, exemple idéal pour illustrer la mise en œuvre d'une architecture MEAN.



Quizinclus dans
la version en ligne !
  • Testez vos connaissances à l'issue de chaque chapitre
  • Validez vos acquis

Table des matières

  • Introduction
    • 1. Introduction
    • 2. L'architecture MEAN pour une application web
      • 2.1 Le principe des applications monopages (single page applications)
      • 2.2 Le paradigme de conception modèle-vue-contrôleur
    • 3. Angular au centre de l'architecture MEAN
    • 4. Présentation du fil rouge : une application d'e-commerce
  • Le langage JavaScript
    • 1. Introduction à JavaScript
      • 1.1 Bref historique
      • 1.2 Panorama de l'utilisation de JavaScript
      • 1.3 Les bibliothèques et les frameworks applicatifs JavaScript
    • 2. Où coder du code JavaScript ?
    • 3. Les outils du navigateur et le débogage
    • 4. Les éléments de programmation de base
      • 4.1 Les variables
        • 4.1.1 Les types internes
        • 4.1.2 Le transtypage
      • 4.2 Les structures de données usuelles
      • 4.3 Application d'expressions régulières
      • 4.4 Les blocs d'instructions
      • 4.5 Les structures conditionnelles
        • 4.5.1 La structure if ... else ...
        • 4.5.2 La structure switch d'aiguillage multiple
      • 4.6 Les structures itératives
        • 4.6.1 Les structures itératives avec indices de boucle
        • 4.6.2 Les structures itératives sans indices de boucle
    • 5. La programmation fonctionnelle en JavaScript
      • 5.1 Une fonction passée en paramètre (fonction de callback)
        • 5.1.1 Exemple avec la méthode forEach()
        • 5.1.2 Exemple avec la méthode map()
      • 5.2 Une fonction retourne une fonction (factory)
    • 6. La programmation objet avec JavaScript
      • 6.1 Les principes de la programmation objet avec JavaScript
      • 6.2 Les objets littéraux
      • 6.3 L'héritage par chaînage de prototypes
        • 6.3.1 La propriété __proto__ de l'objet héritant
        • 6.3.2 La propriété prototype
      • 6.4 La création d'un objet par l'appel d'une fonction constructrice
      • 6.5 Exemples d'implémentations d'une méthode
      • 6.6 La problématique de l'objet courant (this)
      • 6.7 L'héritage
      • 6.8 Le chaînage de méthodes
    • 7. Les principaux apports de la norme ECMAScript 6
      • 7.1 La norme ECMAScript
      • 7.2 Le mot réservé let
      • 7.3 L'interpolation de variables dans les chaînes
      • 7.4 Les paramètres par défaut
      • 7.5 Une manipulation plus confortable des listes
        • 7.5.1 La structure for (... of ...) ...
        • 7.5.2 La méthode includes()
      • 7.6 L'opérateur « fat arrow » (=>)
      • 7.7 Les classes
    • 8. La programmation réactive, les observables et les promises
      • 8.1 Premier exemple : un observable sur un bouton
      • 8.2 Deuxième exemple : un observable sur un entier
      • 8.3 Troisième exemple : un observable sur un timer
      • 8.4 Les promises
  • Extensions JavaScript pour les classes
    • 1. Présentation des extensions à JavaScript
    • 2. Le langage TypeScript
      • 2.1 Le transpiler tsc
      • 2.2 Typage statique des variables
        • 2.2.1 Les types de base
        • 2.2.2 Typage de variables non scalaires
        • 2.2.3 Le type enum
        • 2.2.4 Le type générique any
        • 2.2.5 Typage des fonctions
      • 2.3 Les classes
        • 2.3.1 L'héritage
        • 2.3.2 Les interfaces
        • 2.3.3 La généricité
    • 3. Le langage Dart
      • 3.1 Installation et test de Dart
      • 3.2 Génération du code JavaScript avec Dart
      • 3.3 Les classes
        • 3.3.1 L'héritage
        • 3.3.2 Les interfaces
  • La plateforme Node.js
    • 1. Présentation de Node.js
    • 2. Installation et test de Node.js
      • 2.1 Création du fichier de test
      • 2.2 Installation et test de Node.js sous Ubuntu
      • 2.3 Installation et test de Node.js sous Windows
      • 2.4 Installation et test de Node.js sous Mac OS
    • 3. La modularité de Node.js
      • 3.1 Les modules et les packages
        • 3.1.1 Le gestionnaire de modules de Node.js : npm
        • 3.1.2 Spécification des dépendances : le fichier package.json
      • 3.2 Création d'un premier serveur Node.js de test
      • 3.3 Création et réutilisation d'un module
      • 3.4 Création d'un serveur renvoyant des données
      • 3.5 Le module express
        • 3.5.1 Gestion de routes REST avec le module express
        • 3.5.2 Gestion des templates avec le module express
        • 3.5.3 Spécification des dépendances dans un fichier package.json
        • 3.5.4 Installation du module express
      • 3.6 Le module fs (FileSystem)
      • 3.7 Test d'un serveur Node.js
        • 3.7.1 Création d'un fichier de données JSON
        • 3.7.2 La problématique du contrôle d'accès HTTP
        • 3.7.3 Renvoi au client d'un fichier JSON
        • 3.7.4 Paramétrage des routes
        • 3.7.5 Gestion des paramètres
    • 4. Sécurisation d'un serveur Node.js (protocole HTTPS)
      • 4.1 Création de l'autorité de certification
      • 4.2 Création du certificat
      • 4.3 Création du serveur
    • 5. Bilan des acquis de ce chapitre
  • Le SGBD NoSQL MongoDB
    • 1. Introduction
    • 2. Pourquoi utiliser une base de données NoSQL ?
    • 3. Présentation de MongoDB
      • 3.1 Les collections et les documents
      • 3.2 Les index
    • 4. Mise en œuvre de MongoDB
      • 4.1 Installation de MongoDB
        • 4.1.1 Installation de MongoDB sous Linux
        • 4.1.2 Installation de MongoDB sous Windows ou sous Mac OS
        • 4.1.3 Utilisation de MongoDB en lignes de commande
      • 4.2 Affichage de la liste des bases de données
      • 4.3 Création d'une base de données
      • 4.4 Affichage de la liste des collections
      • 4.5 Création d'une collection
        • 4.5.1 Insertion des documents dans une collection
        • 4.5.2 Importation de documents à partir d'un fichier
        • 4.5.3 Exportation des documents d'une collection dans un fichier JSON
      • 4.6 Interrogation d'une collection
        • 4.6.1 Interrogation via un objet « filtre »
        • 4.6.2 Les opérateurs de comparaison, les opérateurs ensemblistes et logiques
        • 4.6.3 L'opérateur $ exists
        • 4.6.4 L'opérateur $ in
        • 4.6.5 L'opérateur $ nin
        • 4.6.6 L'opérateur $ or
        • 4.6.7 L'opérateur $ not
        • 4.6.8 L'opérateur $ nor
      • 4.7 Application d'expressions régulières
      • 4.8 Les projections et la méthode distinct()
        • 4.8.1 Les projections
        • 4.8.2 La méthode distinct()
      • 4.9 Référencement des documents et jointures
        • 4.9.1 Les objets imbriqués (nested objects)
        • 4.9.2 Les objets référencés
        • 4.9.3 Les jointures
      • 4.10 Mise à jour et suppression d'un document
        • 4.10.1 Mise à jour d'un document
        • 4.10.2 Suppression d'un document
      • 4.11 Suppression d'une collection
    • 5. Utilisation de MongoDB via Node.js
      • 5.1 Installation du module MongoDB pour Node.js
      • 5.2 Connexion au serveur MongoDB
      • 5.3 Insertion de données à partir d'un serveur Node.js
      • 5.4 Interrogation de données à partir d'un serveur Node.js
        • 5.4.1 Exploitation du résultat de la méthode find()
        • 5.4.2 Utilisation de la méthode toArray()
      • 5.5 Synchronisation des requêtes
        • 5.5.1 Utilisation des fonctions de callback
        • 5.5.2 Utilisation du module async
        • 5.5.3 La méthode async.series()
        • 5.5.4 La méthode async.waterfall()
    • 6. Interrogation de MongoDB via les routes gérées par express
      • 6.1 La structure d'un serveur Node.js interrogeant MongoDB
      • 6.2 La problématique du cross-origin resource sharing
      • 6.3 Exemples de gestion de routes
        • 6.3.1 Gestion d'une route pour lister les marques
        • 6.3.2 Gestion d'une route pour filtrer les produits
        • 6.3.3 Recherche d'un produit à partir de son identifiant interne
    • 7. Le fil rouge du côté serveur
      • 7.1 Création de la collection
      • 7.2 Mise en place de deux recherches sur les produits
        • 7.2.1 La superstructure du serveur
        • 7.2.2 Gestion de la route qui filtre les documents sur différents critères
        • 7.2.3 Gestion de la route qui renvoie un document via son identifiant interne
        • 7.2.4 Exemples de requête sur le serveur
    • 8. Bilan des acquis de ce chapitre
  • Introduction au framework applicatif Angular
    • 1. Présentation d'Angular
      • 1.1 Une évolution radicale d'AngularJS
      • 1.2 La modularité de l'application : les modules et les composants
        • 1.2.1 Les modules
        • 1.2.2 Les composants et les services
      • 1.3 Manipulation des composants comme des balises
      • 1.4 Utilisation d'une extension à JavaScript (TypeScript ou Dart)
    • 2. Angular par rapport au framework MVC (voire MVVM)
    • 3. Mise en place d'une application Angular
      • 3.1 Présentation d'Angular CLI
      • 3.2 Installation d'Angular CLI
      • 3.3 Création d'un projet Angular avec Angular CLI
      • 3.4 Structure des dossiers d'un projet Angular CLI
      • 3.5 Un premier composant créé par Angular CLI
      • 3.6 Le root module créé par Angular CLI
      • 3.7 Mise à jour d'Angular via Angular CLI
    • 4. Génération du code JavaScript à partir de TypeScript
    • 5. Les décorateurs
    • 6. Création d'un nouveau composant qui affiche un message
      • 6.1 Création du composant
        • 6.1.1 Le template HTML
        • 6.1.2 La feuille de style
      • 6.2 Interfaçage du composant dans le composant racine
      • 6.3 Spécification des composants dans le module
      • 6.4 Activation du module
      • 6.5 La page web frontale
    • 7. Le cycle de vie d'un composant
      • 7.1 Le hook ngOnChanges()
      • 7.2 Le hook ngOnInit()
      • 7.3 Le hook ngDoCheck()
      • 7.4 Le hook ngOnDestroy()
    • 8. Bilan des acquis de ce chapitre
  • Angular : les templates, bindings et directives
    • 1. Les templates
      • 1.1 Imbrication des templates
      • 1.2 Les templates insérés (embedded templates)
      • 1.3 Les templates externalisés
    • 2. Data bindings entre le composant et le template
      • 2.1 Accès aux éléments du DOM
      • 2.2 Interpolation d'une variable dans un template
      • 2.3 Property binding
      • 2.4 Event binding
      • 2.5 Two-way data binding
    • 3. Les directives
      • 3.1 Les directives structurelles
        • 3.1.1 La directive *ngFor
        • 3.1.2 La directive *ngIf
      • 3.2 Les directives attributs
      • 3.3 Émission d'information d'un composant vers son père (@Output())
    • 4. Les pipes
    • 5. Exemple de synthèse : un formulaire d'authentification
    • 6. Le fil rouge : création d'un composant qui affiche les produits
      • 6.1 Le composant
        • 6.1.1 La classe implémentant le composant
        • 6.1.2 Le template HTML
        • 6.1.3 La feuille de style
      • 6.2 Le module spécifiant le composant
      • 6.3 Activation du module
      • 6.4 La page web frontale
      • 6.5 Lancement de l'application
    • 7. Bilan des acquis de ce chapitre
  • Angular et la connexion à Node.js : les services
    • 1. Introduction
    • 2. Injection de dépendances
    • 3. Utilisation des services pour le transfert de données
      • 3.1 Récupération de données formatées en JSON
      • 3.2 Envoi de données JSON au serveur
      • 3.3 Envoi de données via la querystring
    • 4. Mise en œuvre des services dans le fil rouge
      • 4.1 Déclaration des routes du côté serveur
      • 4.2 Gestion des produits
        • 4.2.1 Affichage des sélecteurs
        • 4.2.2 Affichage des produits suivant des critères de recherche
        • 4.2.3 Affichage des produits associés à des mots-clés
        • 4.2.4 Accès à un produit par son identifiant
      • 4.3 Gestion du panier
        • 4.3.1 Affichage des identifiants des produits du panier
        • 4.3.2 Affichage de tous les produits du panier
        • 4.3.3 Ajout d'un produit au panier
        • 4.3.4 Suppression d'un produit du panier
        • 4.3.5 Réinitialisation du panier
    • 5. La bibliothèque NgRx et les stores
    • 6. Bilan des acquis de ce chapitre
  • Angular et la gestion des routes internes
    • 1. Principe général du routage
      • 1.1 Pourquoi mettre en place un routage ?
      • 1.2 Les routes, le routeur, les tables de routage
      • 1.3 Les vues activées par les routes
      • 1.4 Exemple de routage
      • 1.5 Définition d'un arbre de vues
      • 1.6 Utilisation des outlets nommées
    • 2. La syntaxe des routes
      • 2.1 Les deux syntaxes d'une route : chaîne ou link parameters array
      • 2.2 Les routes absolues et les routes relatives
      • 2.3 Paramétrage des routes
      • 2.4 Association d'une route à une auxiliary outlet
    • 3. Sélection des routes
      • 3.1 La directive routerLink
      • 3.2 La méthode navigate()
      • 3.3 Exemple de route
    • 4. Gestion des routes du contrôleur vers le composant cible
      • 4.1 Configuration de la table de routage
      • 4.2 Les propriétés d'une route
      • 4.3 Prise en charge d'une route par plusieurs modules/tables de routage
      • 4.4 Contrôle des routes : les guards
      • 4.5 Invocation d'un composant
      • 4.6 Capture d'une route lors de l'invocation d'un composant
    • 5. Gestion de routes dans le fil rouge
      • 5.1 Le module de routage associé au root module
      • 5.2 Le module de routage associé au feature module research
      • 5.3 Le module de routage associé au feature module cart
    • 6. Bilan des acquis de ce chapitre
  • Angular et la visualisation d’informations
    • 1. Introduction
    • 2. Création de charts avec D3.js et dc.js
      • 2.1 Installation de D3.js
      • 2.2 Le langage SVG
      • 2.3 Génération d'éléments graphiques associés aux objets d'une collection
      • 2.4 Sélection et modification d'éléments du DOM
        • 2.4.1 Ajout d'éléments graphiques
        • 2.4.2 Remplacement d'éléments graphiques
      • 2.5 Mise en œuvre d'écouteurs d'événements
      • 2.6 Intégration de D3.js dans Angular
        • 2.6.1 Un serveur virtuel de données commerciales
        • 2.6.2 Le service accédant aux données du serveur
        • 2.6.3 Le template du composant qui affiche un histogramme
        • 2.6.4 Implémentation du composant qui affiche un histogramme
      • 2.7 Les bibliothèques dc.js et Crossfilter
        • 2.7.1 Installation de dc.js et de Crossfilter
        • 2.7.2 Implémentation du composant affichant l'histogramme
    • 3. Intégration de cartes Google Map dans un projet Angular
      • 3.1 Installation des prérequis techniques
        • 3.1.1 Installation des types TypeScript
        • 3.1.2 Installation de la bibliothèque PrimeNG
      • 3.2 Présentation d'une carte Google Map statique
      • 3.3 Un composant PrimeNG pour gérer une carte Google Map
      • 3.4 Gestion d'un chart associé à une Google Map
    • 4. Mise en œuvre de composants graphiques
      • 4.1 Autre exemple de composant PrimeNG (Calendar)
      • 4.2 La bibliothèque de composants Material
      • 4.3 La bibliothèque ngx-bootstrap
    • 5. Bilan des acquis de ce chapitre
  • Test et déploiement
    • 1. Test
    • 2. Déploiement
      • 2.1 Déploiement avec Apache
      • 2.2 Déploiement avec Node.js
      • 2.3 Déploiement avec http-server (raccourci sur Node.js)
    • 3. Pour aller plus loin
    • Index

Auteur

Pierre POMPIDOREn savoir plus

Maître de conférences en informatique à l'Université de Montpellier, Pierre Pompidor y enseigne la conception et la programmation d'applications web ainsi que la visualisation d'informations auprès d’étudiants en Licence et en Master. A travers ce livre et avec toute sa pédagogie, il transmet au lecteur ses connaissances sur le développement industriel d’applications web avec une architecture MEAN.

Caractéristiques

  • Niveau Expert à Confirmé
  • Nombre de pages 378 pages
  • Parution juillet 2019
    • Livre (broché) - 17 x 21 cm
    • ISBN : 978-2-409-01961-6
    • EAN : 9782409019616
    • Ref. ENI : EI2ANGNOD
  • Niveau Confirmé à Expert
  • Parution juillet 2019
    • HTML
    • ISBN : 978-2-409-01965-4
    • EAN : 9782409019654
    • Ref. ENI : LNEI2ANGNOD

Téléchargements

En complétant ce formulaire, vous acceptez d'être contacté afin de recevoir des informations sur nos produits et services ainsi que nos communications marketing. Vous aurez la possibilité de vous désabonner de nos communications à tout moment. Pour plus d'informations sur notre politique de protection des données, cliquez ici.
  • Des fichiers complémentaires (1,75 Mo)