Vue.js : développement d'applications web modernes en JavaScript, réalisation d'un jeu de rapidité et d'adresse, 2H30 de vidéo

Auteur(s) :

Gauchard, Yoann Découvrir l'auteur

Résumé

Une présentation du framework JavaScript Vues.js accompagnée de conseils pour installer et configurer des outils d'aide au développement, réagir face aux actions de l'utilisateur, gérer les styles CSS, réaliser un formulaire, organiser son code en composant, utiliser l'empaqueteur de module Webpak, entre autres. Avec une vidéo disponible en ligne expliquant comment réaliser un jeu. ©Electre 2021

Éditeur(s)
- Éditions ENI
Date
- C 2021
Notes
- Contient un "flashcode" permettant d'accéder à un contenu via Internet
Langues
- Français
Description matérielle
- 1 vol. (617 p.) : ill., tabl., graph. ; 21 cm
Collections
- vBook
Sujet(s)
ISBN
- 978-2-409-03199-1
Indice
- 681.230 Langages de script
Quatrième de couverture
- Vue.js
  Livre
  Un livre de référence sur Vue.js pour développer des applications web modernes en JavaScript avec un framework progressif.
  Vidéo
  Un approfondissement sous forme de vidéo* (2 H 30) qui présente le développement avec Vue.js d'un jeu de rapidité et d'adresse.
Tables des matières
- - Vue.js
  - Développement d'applications web modernes en JavaScript
  - Éditions Eni
  - Chapitre 1
  - Introduction
  - 1. Quelles notions ce livre couvre-t-il ?17
  - 2. Prérequis19
  - 3. Historique de Vue.js20
  - 3.1 Pourquoi Vue.js ?20
  - 3.1.1 Ses origines20
  - 3.1.2 Ses atouts21
  - 3.2 Qu'est-ce que le Virtual DOM ?24
  - 3.2.1 Définition24
  - 3.2.2 API DOM pour mettre à jour une page web24
  - 3.2.3 Limites de l'API DOM26
  - 3.2.4 Apparition du concept de DOM virtuel27
  - 3.2.5 Manipulation du DOM virtuel29
  - 3.3 Le DOM virtuel avec Vue.js30
  - 4. Modèles d'architectures32
  - 4.1 MVC (Modèle - Vue - Contrôleur)32
  - 4.1.1 MVC pour toutes applications32
  - 4.1.2 MVC adapté aux applications web33
  - 4.2 MVVM (Model - View - ViewModel)34
  - 5. Comparatifs avec les autres frameworks36
  - 5.1 Popularité entre Vue, React et Angular36
  - 5.2 Avantages et inconvénients38
  - 5.2.1 Angular38
  - 5.2.2 React.js39
  - 5.2.3 Vue.js39
  - 5.2.4 Quel framework pour quel besoin ?40
  - 5.2.5 Aller plus loin dans la comparaison avec les autres frameworks40
  - 6. Futur de Vue.js40
  - Chapitre 2
  - Notions essentielles de JavaScript
  - 1. Introduction43
  - 2. Bases algorithmiques45
  - 2.1 Variables et types de valeurs45
  - 2.1.1 Déclaration d'une variable45
  - 2.1.2 Types de valeurs46
  - 2.1.3 Contextes d'exécution global et local48
  - 2.1.4 Portée de variable50
  - 2.1.5 Conversion de types de données53
  - 2.1.6 Affectation par décomposition55
  - 2.2 Structures de contrôle55
  - 2.2.1 Instructions conditionnelles55
  - 2.2.2 Boucles58
  - 3. Fonctions60
  - 3.1 Définition et utilisation des fonctions60
  - 3.2 Fermetures (closures)61
  - 3.3 Fonction en argument d'autres fonctions63
  - 3.4 Paramètres par défaut et paramètres du reste64
  - 3.5 Fonctions fléchées64
  - 3.6 Fonctions anonymes autoexécutantes65
  - 4. Manipulation de tableaux67
  - 4.1 Déclarer, lire, modifier, supprimer des éléments67
  - 4.2 Itérer sur un tableau69
  - 4.3 Décomposer avec l'opérateur spread69
  - 4.4 Filtrer un tableau70
  - 4.5 Trier un tableau70
  - 5. Manipulation d'objets70
  - 5.1 Définir un objet et son prototype70
  - 5.2 Instancier un objet72
  - 5.3 Lire, ajouter, modifier ou supprimer une propriété75
  - 5.4 Copier ou fusionner des objets76
  - 5.5 Itérer sur un objet77
  - 5.6 Chaîner les méthodes d'objet77
  - 6. Utilisation du mot-clé this78
  - 6.1 En dehors d'une fonction78
  - 6.2 Dans une fonction appelée de manière classique78
  - 6.3 Dans une fonction appelée via call() et apply()79
  - 6.4 Avec bind() pour associer un objet à this79
  - 6.5 Dans une fonction appelée en tant que méthode d'objet80
  - 6.6 Dans un gestionnaire d'évènement80
  - 6.7 Dans une fonction fléchée80
  - 7. Gestion des exceptions81
  - 7.1 L'utilité81
  - 7.2 La structure try...catch...finally82
  - 7.3 L'objet Error et les erreurs personnalisées84
  - 8. Utilisation des promesses85
  - 8.1 Objet natif Promise85
  - 8.2 Méthode then()86
  - 8.3 Gestionnaires de then()87
  - 8.4 Méthode catch()88
  - 8.5 Chaînage de traitements asynchrones avec les promesses90
  - 8.6 Création de promesses déjà tenues ou rompues92
  - 8.7 Exécution de tâches asynchrones en parallèle93
  - 8.8 Gestion de la pile d'appels93
  - 8.9 Fonctions asynchrones avec async94
  - 9. Utilisation des modules JavaScript96
  - 9.1 L'historique des modules JavaScript96
  - 9.1.1 Introduction96
  - 9.1.2 Application sans module97
  - 9.1.3 Objets en tant que modules et fonctions auto-invoquées99
  - 9.1.4 Modules CommonJS100
  - 9.1.5 Modules AMD102
  - 9.1.6 Chargeur de modules104
  - 9.1.7 Empaqueteur de modules106
  - 9.2 Les modules ES 6108
  - 9.2.1 Introduction108
  - 9.2.2 Déclarer et utiliser un module108
  - 9.2.3 Éviter les conflits de nommage109
  - 9.2.4 Agréger plusieurs modules111
  - 9.2.5 Importer dynamiquement111
  - Chapitre 3
  - Comprendre les fondamentaux de Vue.js
  - 1. Installation113
  - 1.1 Une version par environnement113
  - 1.2 Via téléchargement manuel114
  - 1.3 Via l'inclusion d'un CDN (le plus simple)114
  - 1.4 Via npm ou yarn pour de plus gros projets115
  - 1.4.1 Téléchargement du package vue115
  - 1.4.2 Explication des différents builds116
  - 1.5 Via Vue-CLI118
  - 2. Outils de développements119
  - 2.1 VS Code et ses plugins119
  - 2.1.1 Installer et configurer VS Code119
  - 2.1.2 Déboguer avec VS Code121
  - 2.2 Vue Devtools127
  - 2.3 Vue Performance Devtool130
  - 2.4 CodeSandbox132
  - 2.5 Git132
  - 3. Instance Vue.js133
  - 3.1 Hello World133
  - 3.2 Liaison de données entre View et ViewModel137
  - 3.3 Cycle de vie d'une instance139
  - 3.4 Utilisation du mot-clé this142
  - 4. Virtual DOM et réactivité144
  - 4.1 Le système de liaison de données144
  - 4.2 Le fonctionnement de la file d'attente de mise à jour asynchrone147
  - 4.3 La déclaration de propriétés réactives150
  - 4.4 Les limitations de la détection de changement150
  - 4.5 Les directives pour manipuler le DOM152
  - 4.5.1 Un attribut HTML spécial152
  - 4.5.2 Les arguments et les arguments dynamiques155
  - 4.5.3 Les modificateurs155
  - 5. Liaison de données156
  - 5.1 Liaison réactive uni-directionnelle156
  - 5.1.1 Afficher des données réactives avec l'interpolation texte156
  - 5.1.2 Rendre un attribut réactif avec v-bind156
  - 5.2 Liaison bidirectionnelle avec v-model157
  - 6. Affichage des données dans la View158
  - 6.1 L'interpolation avec des données plus complexes158
  - 6.2 La directive v-html159
  - 6.3 La directive v-once160
  - 6.4 Le rendu conditionnel161
  - 6.4.1 La directive v-show161
  - 6.4.2 Les directives v-if, v-else-if et v-else162
  - 6.5 La balise <template>164
  - 7. Traitement et formatage des données165
  - 7.1 Valeurs traitées avec les propriétés calculées165
  - 7.2 Valeurs traitées avec les méthodes167
  - 7.3 Propriétés calculées vs méthodes168
  - 7.4 Mutateurs calculés171
  - 7.5 Valeurs traitées avec les observateurs watch173
  - 7.6 Utilisation des filtres pour formater les données175
  - 8. Affichage de listes de données177
  - 8.1 Utiliser la directive v-for177
  - 8.2 Filtrer les éléments d'une liste180
  - 8.2.1 Ne pas utiliser v-if avec v-for180
  - 8.2.2 En utilisant une propriété calculée182
  - 8.3 Trier les éléments d'une liste184
  - 8.4 Muter un tableau ou un objet185
  - 9. Capture des évènements déclenchés par l'utilisateur189
  - 9.1 Directive v-on189
  - 9.1.1 Mettre à jour une donnée suite à un évènement du DOM189
  - 9.1.2 Récupérer l'évènement dans la méthode191
  - 9.2 Modificateurs d'évènements192
  - 9.3 Évènement dynamique et syntaxe objet193
  - 10. Gestion des styles CSS193
  - 10.1 Scoped styles193
  - 10.2 Les styles dynamiques194
  - 10.3 Les styles dynamiques avec un objet196
  - 10.4 Les styles dynamiques avec un objet sans CSS198
  - Chapitre 4
  - Utiliser les formulaires
  - 1. Les éléments de formulaire199
  - 1.1 L'utilisation de librairies tierces199
  - 1.2 Les champs text et textarea201
  - 1.3 Les cases à cocher et les boutons radio204
  - 1.4 Les listes déroulantes206
  - 2. Les champs particuliers de formulaire209
  - 2.1 Champs date209
  - 2.2 Champs de chargement de fichier211
  - 2.3 Sliders214
  - 3. Les modificateurs de la directive v-model215
  - 3.1 Formater une saisie en tant que nombre215
  - 3.2 Réagir sur l'évènement change plutôt qu'input216
  - 3.3 Retirer les espaces217
  - 4. La validation du formulaire218
  - 4.1 Les librairies de validations de formulaire218
  - 4.2 Utiliser VeeValidate218
  - 4.2.1 Installer218
  - 4.2.2 Utiliser les règles de validation par défaut220
  - 4.2.3 Ajouter ses propres règles de validation226
  - 4.2.4 Gérer la soumission du formulaire228
  - 4.3 Utiliser Vuelidate231
  - 4.3.1 Installer231
  - 4.3.2 Utiliser les règles de validation par défaut232
  - 4.3.3 Ajouter ses propres règles de validation240
  - 4.3.4 Gérer la soumission de formulaire246
  - Chapitre 5
  - Utiliser les composants
  - 1. Qu'est-ce qu'un composant ?249
  - 1.1 Définition249
  - 1.2 Structure d'un composant251
  - 1.3 Structuration d'une application en composants253
  - 2. Création d'un composant254
  - 2.1 Manière globale254
  - 2.2 Manière locale254
  - 3. Communication entre composants255
  - 3.1 Parent - enfant255
  - 3.1.1 Définition des props dans la Vue255
  - 3.1.2 Types de données256
  - 3.1.3 Définition des props dans le ViewModel256
  - 3.1.4 Validation des props257
  - 3.1.5 Utilisation des props dans le ViewModel258
  - 3.2 Enfant - parent260
  - 3.2.1 Emettre un évènement depuis un composant enfant260
  - 3.2.2 Écouter un évènement dans le composant parent260
  - 3.3 Enfant - Enfant262
  - 3.3.1 Limite de l'utilisation des props et des évènements personnalisés262
  - 3.3.2 Utilisation d'un bus d'évènements263
  - 4. Pour aller plus loin264
  - 4.1 Les différentes propriétés d'instance d'un composant264
  - 4.2 L'utilisation de la directive v-model sur un composant265
  - 4.2.1 V-model pour un composant contenant un champ texte265
  - 4.2.2 V-model pour un composant contenant une case à cocher ou un bouton radio266
  - 4.3 L'héritage des attributs du composant267
  - 4.4 Les évènements natifs à relier au composant269
  - 4.5 La liaison bidirectionnelle d'une prop avec le modificateur .sync270
  - 5. Plusieurs types de composants271
  - 5.1 Les composants dynamiques271
  - 5.1.1 L'élément <component> et l'attribut is271
  - 5.1.2 L'élément <keep-alive>272
  - 5.2 Les composants monofichiers273
  - 5.3 Les composants basiques276
  - 5.4 Les composants asynchrones pour améliorer les performances277
  - 5.5 L'utilisation de la fonction render() pour le rendu281
  - 5.6 Les composants fonctionnels285
  - Chapitre 6
  - Mutualiser des fonctionnalités
  - 1. Utiliser les slots pour injecter du contenu289
  - 1.1 Définition289
  - 1.2 Slots nommés293
  - 1.3 Props de slot295
  - 2. Utiliser les composants sans rendu296
  - 2.1 Définition296
  - 2.2 Création d'un composant de captures d'erreurs297
  - 3. Utiliser les mixins302
  - 3.1 Définition302
  - 3.2 Stratégies de fusion des options304
  - 4. Utiliser les plugins307
  - 4.1 Définition307
  - 4.2 Optimisation des performances311
  - 4.2.1 Vérifier la taille des plugins et leur vitesse de chargement311
  - 4.2.2 Utiliser le tree-shaking pour les plugins qui le permettent313
  - 5. Les directives personnalisées315
  - 5.1 Définition315
  - 5.2 Arguments et modificateurs318
  - Chapitre 7
  - Créer et déployer une application avec Vue CLI
  - 1. Plusieurs types d'applications321
  - 1.1 Une SPA classique321
  - 1.1.1 Définition321
  - 1.1.2 Contraintes d'une SPA classique322
  - 1.2 Une application universelle (SPA + SSR)323
  - 1.2.1 Définition323
  - 1.2.2 Contraintes d'une application universelle325
  - 1.3 Un générateur de site statique327
  - 1.3.1 Définition327
  - 1.3.2 Architecture JAMstack329
  - 1.3.3 Contraintes des sites statiques332
  - 1.4 Une PWA332
  - 1.4.1 Définition332
  - 1.4.2 Différents types de caches333
  - 1.4.3 Contraintes d'une PWA335
  - 1.5 Quel type d'application pour quel besoin ?336
  - 2. Création d'un projet avec Vue CLI337
  - 2.1 Présentation337
  - 2.2 Installation339
  - 2.2.1 Prérequis339
  - 2.2.2 Prototypage rapide d'une application339
  - 2.2.3 Création d'une application Vue.js complète340
  - 2.3 Comprendre l'arborescence du projet348
  - 2.3.1 Racine du projet348
  - 2.3.2 Dossier src349
  - 2.3.3 Modification de l'arborescence pour un projet de taille moyenne351
  - 2.3.4 Modification de l'arborescence pour un gros projet356
  - 3. Fonctionnalités de Vue CLI358
  - 3.1 Les plugins et les presets358
  - 3.1.1 Les plugins358
  - 3.1.2 Les presets360
  - 3.2 Le rechargement à chaud361
  - 3.3 La configuration de Webpack362
  - 3.3.1 Comprendre le fonctionnement362
  - 3.3.2 Accéder aux fichiers de configurations des différents modes365
  - 3.3.3 Modifier la configuration366
  - 3.3.4 Utiliser PAPI de chaînage pour modifier plus finement la configuration369
  - 3.4 Les modes et variables d'environnement370
  - 3.4.1 Les modes pour chaque environnement370
  - 3.4.2 Les variables d'environnement371
  - 3.5 Le dossier public375
  - 3.5.1 Interpolation dans les fichiers HTML375
  - 3.5.2 Fichiers statiques376
  - 3.6 La compatibilité des navigateurs377
  - 3.6.1 La liste des navigateurs compatibles377
  - 3.6.2 Le mode moderne378
  - 3.6.3 Les contrôles CORS en mode moderne pour les modules ES6378
  - 4. Déploiement de votre application en production380
  - 4.1 Procédure de déploiement380
  - 4.1.1 Compiler votre application avec Webpack380
  - 4.1.2 Prévisualiser en local381
  - 4.1.3 Déployer votre application sur un serveur381
  - 4.2 Déploiement simple avec des plateformes PaaS382
  - 4.2.1 Déployer sur Netlify382
  - 4.2.2 Déployer sur Heroku385
  - 4.2.3 Créer une image Docker avec Nginx387
  - Chapitre 8
  - Consommer des API REST et GraphQL
  - 1. Plusieurs types d'API (REST et GraphQL)391
  - 1.1 Définition et historique391
  - 1.2 API REST392
  - 1.2.1 Définition392
  - 1.2.2 Contraintes d'une API REST395
  - 1.3 API GraphQL399
  - 1.3.1 Définition399
  - 1.3.2 Description du fonctionnement402
  - 2. Sécurité et modes d'authentification403
  - 2.1 Principes à adopter403
  - 2.2 Cookie d'authentification405
  - 2.2.1 Cookie de session405
  - 2.2.2 Attaques CSRF (Cross Site Request Forgery)406
  - 2.2.3 Attaques XSS (Cross Site Scripting)407
  - 2.3 Authentification basique (Basic)408
  - 2.4 Authentification avec jeton porteur (Bearer)409
  - 2.5 Authentification avec jeton signé (Bearer + JWT)409
  - 2.5.1 Signature409
  - 2.5.2 Principe clé privée - clé publique410
  - 2.5.3 Composition d'un jeton JWT410
  - 2.6 Authentification avec une clé API411
  - 2.6.1 Authentification de l'application par le fournisseur d'API411
  - 2.6.2 Problématique de sécurité sur le réseau de l'utilisateur412
  - 2.6.3 Où conserver les clés API ?412
  - 2.7 Authentification avec OAuth 2.0413
  - 2.7.1 Un serveur d'authentification413
  - 2.7.2 La problématique de conservation du jeton415
  - 3. Créer une API rapidement avec Strapi416
  - 3.1 Créer le backend de votre API416
  - 3.1.1 Présentation416
  - 3.1.2 Installation418
  - 3.2 Créer le schéma de base de données421
  - 3.2.1 Présentation du tableau de bord421
  - 3.2.2 Créer le schéma de base de données423
  - 3.2.3 Gérer les rôles et les permissions430
  - 3.3 Tester l'API REST432
  - 3.3.1 Tester les requêtes GET, POST, PUT et DELETE432
  - 3.3.2 Utiliser des paramètres pour filtrer une collection437
  - 3.4 Tester l'API CraphQL438
  - 3.4.1 Utiliser Postman ou l'éditeur GraphQL de Strapi438
  - 3.4.2 Récupérer des données442
  - 3.4.3 Créer un enregistrement444
  - 3.4.4 Modifier un enregistrement446
  - 3.4.5 Supprimer un enregistrement447
  - 3.4.6 Utiliser des filtres448
  - 3.4.7 Fonctions d'agrégation et clause groupBy450
  - 4. Fetch et Axios pour consommer des API REST454
  - 4.1 Fetch454
  - 4.1.1 Définition et usage454
  - 4.1.2 Les objets Request et Response454
  - 4.1.3 Gérer les erreurs459
  - 4.1.4 Interrompre une requête460
  - 4.1.5 Limiter les appels trop fréquents avec debounce et throttle461
  - 4.1.6 Exécuter des requêtes en parallèle463
  - 4.2 Création d'un catalogue de produits464
  - 4.2.1 Afficher la liste des produits avec fetch464
  - 4.2.2 Gérer les erreurs avec un composant sans rendu469
  - 4.2.3 Mutualiser la fonctionnalité d'appel API475
  - 4.2.4 Mettre en place une pagination478
  - 4.2.5 Ajouter un menu déroulant pour filtrer la liste par catégorie.483
  - 4.2.6 Utiliser une barre de recherche490
  - 4.3 Axios493
  - 4.3.1 Définition et usage493
  - 4.3.2 L'objet config et l'objet response495
  - 4.3.3 Gérer les erreurs499
  - 4.3.4 Interrompre une requête501
  - 4.3.5 Utiliser les intercepteurs502
  - 4.3.6 Centraliser la configuration axios dans l'application503
  - 5. Apollo pour consommer des API GraphQL505
  - 5.1 Installation505
  - 5.1.1 Installation avec Vue CLI505
  - 5.1.2 Installation manuelle pour consommer une API Strapi505
  - 5.1.3 Installation du plugin VS Code507
  - 5.2 Récupérer des données508
  - 5.2.1 Les requêtes intelligentes508
  - 5.2.2 Utiliser des paramètres dans la requête513
  - 5.2.3 Requête conditionnelle515
  - 5.2.4 Modifier les données reçues515
  - 5.2.5 Intercepter les erreurs516
  - 5.2.6 Les options supplémentaires517
  - 5.3 Placer le code des requêtes dans des fichiers .gql518
  - 5.3.1 Créer un fichier .gql518
  - 5.3.2 Importer un fichier .gql519
  - 5.3.3 Utiliser les fragments520
  - 5.4 Créer, modifier ou supprimer une ressource521
  - 5.4.1 La méthode this.Sapollo.mutate521
  - 5.4.2 Le composant ApolloMutation524
  - 5.5 Mise à jour du catalogue de produits avec Apollo525
  - 5.5.1 Nettoyer l'ancienne logique métier de l'API REST525
  - 5.5.2 Définir les requêtes GraphQL525
  - 5.5.3 Définition des requêtes intelligentes528
  - Chapitre 9
  - Utiliser Vue Router pour la navigation
  - 1. Définition et installation533
  - 1.1 Définition533
  - 1.2 Installation534
  - 1.2.1 Télécharger le plugin ou utiliser un CDN534
  - 1.2.2 Utiliser npm534
  - 1.2.3 Utiliser Vue CLI534
  - 1.3 Déclaration du routeur535
  - 2. Usage536
  - 2.1 Définition d'une route536
  - 2.2 Résolution d'une route538
  - 2.3 Mode historique541
  - 2.4 Affichage des composants dans des vues routeur542
  - 2.4.1 La vue par défaut542
  - 2.4.2 Les vues nommées544
  - 2.5 Naviguer à l'aide des liens <router-link>546
  - 2.5.1 Fonctionnement546
  - 2.5.2 La classe active546
  - 2.5.3 Les props de <router-link>547
  - 2.5.4 Les routes nommées548
  - 2.6 Routes dynamiques548
  - 2.6.1 Utilisation des segments dynamiques548
  - 2.6.2 Récupérer les segments dynamiques avec Sroute550
  - 2.6.3 Utiliser les segments dynamiques pour passer des valeurs aux props d'un composant551
  - 2.6.4 Passage entre deux chemins liés à la même route553
  - 2.7 Les routes imbriquées553
  - 3. Navigation programmée555
  - 3.1 Navigation programmée avec Srouter555
  - 3.1.1 $router.push() et Srouter.replace()555
  - 3.1.2 Srouter.forward(), Srouter.back(), Srouter.go()556
  - 3.2 Les intercepteurs de navigation556
  - 3.2.1 Des intercepteurs globaux, par route ou par composant556
  - 3.2.2 Flux de résolution lors d'un passage d'une route à l'autre558
  - 3.2.3 Déclaration d'un intercepteur559
  - 3.2.4 Exemple d'utilisation d'un intercepteur global560
  - 3.2.5 Exemple de chargement de données avant la navigation561
  - 3.3 Les redirections562
  - 4. Pour aller plus loin563
  - 4.1 Les transitions563
  - 4.1.1 Le composant <transition>563
  - 4.1.2 Exemple d'une transition entrante et sortante en fondu565
  - 4.2 Optimisation des performances566
  - 4.2.1 Utilisation du lazy-loading avec les composants asynchrones566
  - 4.2.2 Utiliser le préchargement avec la méthode webpackPrefetch568
  - Chapitre 10
  - Utiliser Vuex pour la gestion d'états
  - 1. Partager un état global entre plusieurs composants569
  - 1.1 Problématique569
  - 1.1.1 Le flux de donnée unidirectionnel569
  - 1.1.2 Utiliser les props et les évènements pour partager et accéder à l'état global570
  - 1.1.3 Utiliser un bus d'évènement pour réagir aux actions571
  - 1.2 Utilisation d'un store pour centraliser les données572
  - 1.2.1 Déporter les états dans un objet partagé572
  - 1.2.2 Tracer les mutations573
  - 1.2.3 Utiliser Vuex575
  - 2. Installer et utiliser le store Vuex577
  - 2.1 Installation577
  - 2.1.1 Avec un CDN577
  - 2.1.2 Avec npm ou yarn577
  - 2.1.3 Avec Vue CLI579
  - 2.2 État580
  - 2.2.1 Définir et accéder à une donnée de l'état580
  - 2.2.2 Utiliser mapState() pour générer les propriétés calculées581
  - 2.3 Accesseurs583
  - 2.3.1 Accéder à une donnée d'état via un accesseur583
  - 2.3.2 Utiliser mapGetters() pour générer les propriétés calculées585
  - 2.4 Mutateurs586
  - 2.4.1 Muter une donnée de l'état du store586
  - 2.4.2 Muter plusieurs données avec une mutation588
  - 2.4.3 Muter un objet ou un tableau590
  - 2.4.4 Utiliser un fichier de constantes pour lister les types de mutations591
  - 2.4.5 Utiliser mapMutations() pour générer les propriétés calculées592
  - 2.4.6 Les mutations avec la directive v-model593
  - 2.5 Actions595
  - 2.5.1 Utiliser les actions pour des traitements asynchrones595
  - 2.5.2 Utiliser mapActions pour générer les méthodes597
  - 2.5.3 Chaîner des actions asynchrones597
  - 3. Utiliser les modules pour organiser son store599
  - 3.1 Séparer le store en plusieurs fichiers599
  - 3.2 Utiliser les modules Vuex601
  - Conclusion603
  - Index605
Origine de la notice:
- Electre