Tutoriel pour apprendre le framework Vue.js version 1

Plus loin avec Vue.js

Maurice Chavelli

Nous avons vu dans la première partie de cette série des notions utiles en programmation et prédéfines dans Vue.js. Dans ce tutoriel, nous allons voir comment définir les notions de filtres, directives et composants sur mesure selon ses besoins.

Commentez

- Titre : Tutoriel pour apprendre le framework Vue.js version 1

- Auteur : Maurice Chavelli

- Parution : 17 juillet 2017

- Licence : Copyright ® 2017 Laravel. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Créer un filtre

- I-A. Les filtres prédéfinis

- I-B. Un filtre sur mesure

- I-C. Passage d'un argument

- I-C-1. Argument optionnel

- I-D. Argument dynamique

- I-E. Filtre à double sens

- I-F. Le panier amélioré

- I-G. En résumé

- II. Créer une directive

- II-A. Les directives prédéfinies

- II-B. Une directive personnalisée

- II-C. Un argument

- II-D. Plusieurs valeurs

- II-E. Une directive élément

- II-F. Le panier

- II-G. En résumé

- III. Créer un composant

- III-A. Mon premier composant

- III-B. Passage de données

- III-B-1. Passage d'une valeur

- III-B-2. camelCase

- III-B-3. Attribut dynamique

- III-C. Gestion des listes

- III-D. Un tableau

- III-E. Un composant générique

- III-F. Un template élégant

- III-G. Le panier revisité

- III-H. En résumé

- IV. Les extensions

- IV-A. Un plugin ?

- IV-B. Le plugin vue-resource

- IV-C. Une API

- IV-C-1. Un serveur de développement

- IV-C-2. Composer

- IV-C-2-a. On crée notre application côté serveur

- IV-D. L'application

- IV-D-1. Ajouter un nom

- IV-D-2. Supprimer un nom

- IV-E. Le template

- IV-F. La ressource

- IV-G. Ajouter un nom

- IV-H. Supprimer un nom

- IV-I. En résumé

- V. Remerciements

I - Créer un filtre

I-A - Les filtres prédéfinis

Vue.js est déjà bien équipé en filtres prédéfinis :

- capitalize : met le premier caractère en capitale ;

- uppercase : met tous les caractères en capitales ;

- lowercase : met tous les caractères en minuscules ;

- currency : ajoute en début le symbole de la monnaie qu'on peut passer en argument (défaut : $) ;

- pluralize : permet de mettre au pluriel avec la possibilité de jouer avec plusieurs formes ;

- json : transforme en JSON ;

- limitBy : limite le nombre d'arguments dans une liste générée par v-for ;

- filterBy : filtre les éléments d'une liste générée par v-for ;

- orderBy : trie les éléments d'une liste générée par v-for.

Ces filtres sont nombreux et bien pratiques, certains sont équipés d'arguments permettant de moduler leurs effets. Nous les avons presque tous rencontrés au cours de la première partie de cette série de tutoriels.

I-B - Un filtre sur mesure

Si on sort des cas d'utilisation des filtres prédéfinis alors c'est le moment d'en créer un personnalisé. Par exemple, il se peut que le filtre currency ne nous plaise pas trop parce qu'il ajoute le symbole de la monnaie au début alors qu'on préfèrerait le voir à la fin. Une bonne occasion de créer un filtre !

Voici le HTML :

<div id="tuto">
<p v-text="montant | euros"></p>
</div>

On voit qu'on a associé à la propriété montant le filtre euros qui n'existe pas dans la panoplie de base.

Voici le JavaScript :

1. new Vue({

2. el: '#tuto',

3. data: {

4. montant: '23.50'

5. },

6. filters: {

7. euros: function(valeur) {

8. return valeur + ' €';

9. }

10. }

11. });

La partie nouvelle dans ce code est constituée par la propriété filters qui permet de créer des filtres. Ici on crée le filtre euros et on définit son action avec une fonction.

Un filtre personnalisé comporte automatiquement un paramètre qui transmet la valeur de la propriété associée, ici le contenu de montant. Il suffit alors de retourner ce montant en lui ajoutant le symbole à la fin et on obtient :

23.50 €

Voici une illustration du fonctionnement :

I-C - Passage d'un argument

Un filtre sur mesure peut aussi accepter un ou plusieurs arguments. Reprenons le cas du symbole monétaire vu ci-dessus et améliorons-le pour accepter le symbole :

Voici le nouveau HTML :

<p v-text="montant | devise '€'"></p>

Et le JavaScript :

1. filters: {

2. devise: function(valeur, symbole) {

3. return valeur + ' ' + symbole;

4. }

5. }

On voit qu'on récupère l'argument dans la fonction en deuxième position puisque la première est d'office affectée à la valeur de la propriété. Pour le reste le fonctionnement est exactement le même à la différence que maintenant on peut choisir le symbole monétaire sans changer le filtre.

Voici un schéma de fonctionnement :

I-C-1 - Argument optionnel

L'argument d'un filtre peut être optionnel, dans ce cas il prend une valeur par défaut si aucune valeur n'est transmise. C'est le cas de certains filtres prédéfinis. Voyons un cas avec un filtre sur mesure.

Supposons que nous voulons un filtre qui affiche une valeur avec le symbole pourcentage et en limitant le nombre de décimales selon une valeur passée comme argument, avec deux décimales par défaut.

Voici le HTML :

<div id="tuto">
<p v-text="montant | pourcentage"></p>
</div>

Et voici le JavaScript :

1. new Vue({

2. el: '#tuto',

3. data: {

4. montant: 23.514

5. },

6. filters: {

7. pourcentage: function(valeur, decimales) {

8. if(decimales === undefined) {

9. decimales = 2;

10. }

11. return Math.round(valeur * Math.pow(10, decimales)) / Math.pow(10, decimales) + ' %';

12. }

13. }

14. });

Le résultat est :

23.51 %

Comme on n'a pas passé de valeur, le nombre de décimales s'est fixé par défaut à 2. Si on en passe un :

<p v-text="montant | pourcentage 1"></p>

Alors le résultat change en conséquence :

23.5 %

I-D - Argument dynamique

L'argument peut lui-même être une variable est donc posséder une valeur selon le contexte du script. Cela peut être très intéressant, mais commençons par voir ce fonctionnement avec un cas simple :

1. <div id="tuto">

2. <form>

3. <div class="form-group">

4. <input type="text" class="form-control" v-model="saisie">

5. </div>

6. </form>

7. <p>{{ 'Texte saisi : ' | ajoute saisie }}</p>

8. </div>

On a une zone de texte liée à la propriété saisie. D'autre part on affiche avec mustache un texte avec un filtre (ajoute) et un argument dynamique pour ce filtre qui est justement la propriété saisie.

Voici le JavaScript :

1. new Vue({

2. el: '#tuto',

3. data: {

4. saisie: ''

5. },

6. filters: {

7. ajoute: function(valeur, saisie) {

8. return valeur + saisie;

9. }

10. }

11. });

Le filtre se contente d'ajouter ce qui est dans saisie au texte :

Voici une illustration des liaisons :

Bon c'est un peu embrouillé, mais ça donne une idée du fonctionnement.

L'exemple ci-dessus n'est pas très réaliste, mais il a le mérite de montrer comment ça fonctionne. Voyons donc à présent un cas un peu plus intéressant. On va créer un filtre pour limiter le nombre de mots affichés dans un texte :

1. <div id="tuto">

2. <p>{{ texte | limite nbrMots }}</p>

3. <form>

4. <div class="form-group">

5. <select class="form-control" v-model="nbrMots">

6. <option>1</option>

7. <option>2</option>

8. <option>3</option>

9. <option>4</option>

10. <option>5</option>

11. <option>6</option>

12. </select>

13. </div>

14. </form>

15. </div>

On a donc un paragraphe pour l'affichage et une liste de choix avec des valeurs de 1 à 6.

Voici le JavaScript :

1. new Vue({

2. el: '#tuto',

3. data: {

4. texte: 'Juste un petit texte pour tester ce filtre.',

5. nbrMots: 3

6. },

7. filters: {

8. limite: function(valeur, nbrMots) {

9. return valeur.split(' ').slice(0, nbrMots).join(' ');

10. }

11. }

12. });

On crée le filtre limite qui attend comme second argument le nombre de mots à afficher.

On obtient :

On affiche bien trois mots. Si on change la valeur :

On affiche cette fois cinq mots.

I-E - Filtre à double sens

Jusque là on a vu uniquement comment on peut modifier à l'affichage une donnée récupérée dans le modèle. Et si on faisait aussi l'inverse ?

Prenons un exemple simple : on va entrer du texte en interdisant de raccourcir la longueur du texte déjà saisi :

1. <div id="tuto">

2. <p>{{ message }}</p>

3. <form>

4. <div class="form-group">

5. <input type="text" class="form-control" v-model="message | limite">

6. </div>

7. </form>

8. </div>

Donc une simple zone de texte et une directive v-model dans laquelle on a prévu un filtre personnalisé.

Voilà le JavaScript :

1. new Vue({

2. el: '#tuto',

3. data: {

4. message: 'Bonjour à toi'

5. },

6. filters: {

7. limite: {

8. read: function(valeur){

9. return valeur;

10. },

11. write: function(nouvelleValeur, ancienneValeur){

12. return nouvelleValeur.length < ancienneValeur.length ? ancienneValeur : nouvelleValeur;

13. }

14. }

15. }

16. });

On divise le code du filtre en deux fonctions, une pour la lecture (read) et l'autre pour l'écriture (write). Au départ on a :

Si on ajoute du texte pas de souci :

Mais on ne peut pas le raccourcir…

Notez que pour la partie lecture, on se contente de renvoyer la valeur. En effet, ce genre de filtre ne peut se concevoir que pour un contrôle de formulaire avec une directive v-model. Or dans ce cas, il y a un double lien et la partie lecture est donc inutile.

I-F - Le panier amélioré

Maintenant que nous savons créer des filtres, même dans les deux sens, nous allons en profiter pour améliorer l'exemple du panier que nous avons vu à la fin de la première partie de cette série de tutoriels. Nous allons :

- utiliser le filtre devise que nous avons créé dans ce tutoriel ;

- créer un filtre entier pour filtrer uniquement les nombres entiers en prévoyant une valeur maximale à passer en argument ;

- créer un filtre flottant pour filtrer les nombres flottants.

Voici le nouveau code de la page :

1. <!DOCTYPE html>

2. <html lang="fr">

4. <head>

5. <meta charset="utf-8">

6. <meta http-equiv="X-UA-Compatible" content="IE=edge">

7. <meta name="viewport" content="width=device-width, initial-scale=1">

8. <title>Test vue.js</title>

9. <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css">

10. <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.3.0/css/font-awesome.min.css">

11. </head>

13. <body>

15. <div class="container" id="tuto">

16. <br>

18. <div class="panel panel-primary">

19. <div class="panel-heading">Panier</div>

20. <table class="table table-bordered table-striped">

21. <thead>

22. <tr>

23. <th class="col-sm-4">Article</th>

24. <th class="col-sm-2">Quantité</th>

25. <th class="col-sm-2">Prix</th>

26. <th class="col-sm-2">Total</th>

27. <th class="col-sm-1"></th>

28. <th class="col-sm-1"></th>

29. </tr>

30. </thead>

31. <tbody>

32. <tr v-for="item in panier">

33. <td>{{ item.article | capitalize }}</td>

34. <td>{{ item.quantite }}</td>

35. <td>{{ item.prix | devise '€' }}</td>

36. <td>{{ item.quantite * item.prix | devise '€' }}</td>

37. <td><button class="btn btn-info btn-block" v-on:click="modifier($index)"><i class="fa fa-edit fa-lg"></button></td>

38. <td><button class="btn btn-danger btn-block" v-on:click="supprimer($index)"><i class="fa fa-trash-o fa-lg"></i></button></td>

39. </tr>

40. <tr>

41. <td colspan="3"></td>

42. <td><strong>{{ total | devise '€' }}</strong></td>

43. <td colspan="2"></td>

44. </tr>

45. <tr>

46. <td><input type="text" class="form-control" v-model="input.article | capitalize" v-el:modif placeholder="Article"></td>

47. <td><input type="text" class="form-control" v-model="input.quantite | entier 10" placeholder="Quantité"></td>

48. <td><input type="text" class="form-control" v-model="input.prix | flottant" placeholder="Prix"></td>

49. <td colspan="3"><button class="btn btn-primary btn-block" v-on:click="ajouter()">Ajouter</button></td>

50. </tr>

51. </tbody>

52. </table>

53. </div>

55. </div>

57. <script src="http://cdn.jsdelivr.net/vue/1.0.10/vue.min.js"></script>

59. <script>

61. new Vue({

62. el: '#tuto',

63. data: {

64. panier: [

65. { article: "cahier", quantite: 2, prix: 5.30 },

66. { article: "crayon", quantite: 4, prix: 1.10 },

67. { article: "gomme", quantite: 1, prix: 3.25 }

68. ],

69. input: { article: '', quantite: 0, prix: 0 }

70. },

71. computed: {

72. total: function () {

73. var total = 0;

74. this.panier.forEach(function(el) {

75. total += el.prix * el.quantite;

76. });

77. return total;

78. }

79. },

80. methods: {

81. ajouter: function() {

82. this.panier.push(this.input);

83. this.input = { article: '', quantite: 0, prix: 0 };

84. },

85. modifier: function(index) {

86. this.input = this.panier[index];

87. this.panier.splice(index, 1);

88. this.$$.modif.focus();

89. },

90. supprimer: function(index) {

91. this.panier.splice(index, 1);

92. },

93. },

94. filters: {

95. devise: function(valeur, symbole) {

96. return valeur + ' ' + symbole;

97. },

98. entier: {

99. read: function(valeur) {

100. return valeur;

101. },

102. write: function(nouvelleValeur, ancienneValeur, max) {

103. var valeur = parseInt(nouvelleValeur);

104. if(valeur % 1 === 0) {

105. return valeur > max ? ancienneValeur : valeur;

106. }

107. return 0;

108. }

109. },

110. flottant: {

111. read: function(valeur) {

112. return valeur;

113. },

114. write: function(nouvelleValeur, ancienneValeur) {

115. return isNaN(nouvelleValeur) ? ancienneValeur : nouvelleValeur;

116. }

117. }

118. }

119. });

121. </script>

123. </body>

125. </html>

On voit qu'on utilise maintenant le filtre devise à la place du filtre prédéfini currency :

1. <td>{{ item.prix | devise '€' }}</td>

2. <td>{{ item.quantite * item.prix | devise '€' }}</td>

3. ,..

4. <td><strong>{{ total | devise '€' }}</strong></td>

On voit également l'ajout des filtres entier et flottant pour la quantité et le prix :

<td><input type="text" class="form-control" v-model="input.quantite | entier 10" placeholder="Quantité"></td>
<td><input type="text" class="form-control" v-model="input.prix | flottant" placeholder="Prix"></td>

Les filtres sont définis dans la partie JavaScript :

1. filters: {

2. devise: function(valeur, symbole) {

3. return valeur + ' ' + symbole;

4. },

5. entier: {

6. read: function(valeur) {

7. return valeur;

8. },

9. write: function(nouvelleValeur, ancienneValeur, max) {

10. var valeur = parseInt(nouvelleValeur);

11. if(valeur % 1 === 0) {

12. return valeur > max ? ancienneValeur : valeur;

13. }

14. return 0;

15. }

16. },

17. flottant: {

18. read: function(valeur) {

19. return valeur;

20. },

21. write: function(nouvelleValeur, ancienneValeur) {

22. return isNaN(nouvelleValeur) ? ancienneValeur : nouvelleValeur;

23. }

24. }

25. }

On voit qu'on peut ajouter un argument (ou même plusieurs) à la partie « write » d'un filtre bidirectionnel.

Le fonctionnement est le même que celui que nous avons vu précédemment pour ce panier. La différence introduite par le filtre devise est que maintenant le symbole monétaire se situe après la valeur :

D'autre part dans le formulaire on ne peut entrer que des valeurs entières inférieures à 10 dans la zone « quantité » avec le filtre entier, et que des nombres (entiers ou flottants) dans la zone « prix » à l'aide du filtre flottant.

I-G - En résumé

- Vue.js est équipé de nombreux filtres prédéfinis.

- Vue.js permet de créer des filtres personnalisés.

- On peut ajouter des arguments à un filtre personnalisé.

- Un argument de filtre peut être dynamique.

- Un filtre peut être bidirectionnel.

II - Créer une directive

Nous avons vu les directives dans la première partie de cette série de tutoriels. Il s'agissait alors des directives prédéfinies dans vue.js. Dans le présent chapitre, nous allons voir comment créer une directive sur mesure selon ses besoins pour étendre les possibilités de vue.js.

II-A - Les directives prédéfinies

Vue.js est déjà bien équipé en directives prédéfinies :

- v-text : modifie le contenu texte ;

- v-html : modifie le contenu HTML ;

- v-if : fait apparaître ou disparaître un élément selon une valeur booléenne ;

- v-show : permet de masquer ou faire apparaître un élément ;

- v-else : à utiliser avec v-if et v-show ;

- v-on : permet de mettre en place un événement ;

- v-bind : permet de créer une liaison ;

- v-model : permet de lier la valeur d'un contrôle de formulaire ;

- v-for : crée un objet vue.js pour chaque élément se trouvant dans un tableau ou un objet ;

- v-transition : applique une transition ;

- v-ref : crée une référence d'un composant enfant pour son parent ;

- v-el : crée une référence d'un élément du DOM.

Ces directives sont nombreuses et bien pratiques. Nous en avons rencontré plusieurs lors de la première partie de ce cours.

II-B - Une directive personnalisée

Si on sort des cas d'utilisation des directives prédéfinies alors c'est le moment d'en créer une sur mesure. Par exemple nous voulons créer une directive pour afficher un titre avec des règles de style spécifiques. Sur le fond, l'exemple est un peu stupide parce qu'il suffit de créer une classe CSS pour aboutir au même résultat, mais ça va nous permettre de commencer avec la création de directives de façon simple :

<div id="tuto">
<div v-titre="Mon titre"></div>
</div>

Je définis une directive v-titre et je donne le texte du titre de façon littérale.

Voici le JavaScript :

1. new Vue({

2. el: '#tuto',

3. directives: {

4. titre: {

5. bind: function() {

6. this.el.style.color = 'Yellow';

7. this.el.style.backgroundColor = 'DarkBlue';

8. this.el.style.textAlign = 'center';

9. this.el.style.fontSize = 'x-large';

10. this.el.style.padding = '20px';

11. this.el.innerHTML = this.expression;

12. }

13. }

14. }

15. });

On voit apparaître une nouvelle propriété pour notre objet vue.js : directives. C'est ici que nous définissons les directives propres à cet objet.

On commence par nommer la directive (titre) et ensuite on définit son fonctionnement.

La méthode bind a pour objet de relier la directive à l'élément du DOM, elle est appelée une seule fois au démarrage (de la même manière on peut utiliser unbind qui est appelée une seule fois lorsque la liaison avec le DOM est supprimée). On a deux propriétés de la directive intéressantes :

- el : pour connaître l'élément du DOM lié à la directive, on peut alors manipuler cet élément à notre guise, ici je fixe des règles de style et le contenu ;

- expression : le contenu de l'expression.

Si on regarde de plus près les propriétés, on trouve :

Le résultat visuel est :

II-C - Un argument

Une directive peut utiliser un argument. Voici un exemple :

<div id="tuto">
<div v-titre:1="titre"></div>
</div>

Ici la directive v-titre a l'argument 1 et la valeur titre. Voici le JavaScript :

1. new Vue({

2. el: '#tuto',

3. data: {

4. titre: 'Mon titre'

5. },

6. directives: {

7. titre: function(value) {

8. this.el.innerHTML =

9. '<h' + this.arg + '>' +

10. value +

11. '</h' + this.arg + '>';

12. }

13. }

14. });

On voit qu'il y a juste une fonction pour la directive qui correspond en fait à update. Comme c'est la seule utilisée, on n'a pas besoin de préciser qu'il s'agit d'elle.

Une directive peut avoir ces trois fonctions toutes optionnelles :

- bind : on l'a déjà vue ci-dessus, elle est appelée une seule fois lors de la liaison ;

- update : appelée juste après bind et à chaque fois que les données liées changent ;

- unbind : appelée une seule fois lors de la rupture de la liaison.

Voilà un petit point sur les propriétés :

Le résultat est la valeur de « titre » dans une balise h1 :

Si on utilise :

<div v-titre:2="titre"></div>

Alors on aura une balise h2 et ainsi de suite.

On se rend compte qu'une directive possède un certain nombre de propriétés bien pratiques. Faisons un peu le point :

- el : il s'agit de l'élément du DOM en liaison avec la directive (dans notre cas « div ») ;

- expression : l'expression de la liaison en excluant l'argument ou un éventuel filtre (dans notre cas c'est « titre ») ;

- arg : l'argument (dans notre cas c'est « 1 »).

On a d'autres propriétés moins utiles :

- raw : c'est la totalité de ce qui est transmis (dans notre cas « titre » ) ;

- name : c'est le nom de la directive (dans notre cas « titre »).

II-D - Plusieurs valeurs

Des fois, on a besoin de plusieurs valeurs. Voyons un exemple de réalisation :

<div id="tuto">
<div v-titre="{type : 1, texte : titre}"></div>
</div>

On transmet un littéral objet. Voici le JavaScript :

1. new Vue({

2. el: '#tuto',

3. data: {

4. titre: 'Mon titre'

5. },

6. directives: {

7. titre: function(value) {

8. this.el.innerHTML =

9. '<h' + value.type + '>' +

10. value.texte +

11. '</h' + value.type + '>';

12. }

13. }

14. });

Voici l'état des propriétés :

On obtient à nouveau le texte dans une balise h1 :

Dans ce cas, on récupère directement les valeurs à partir de l'expression. On pourrait aussi transmettre les valeurs séparément, mais alors la directive serait appelée plusieurs fois.

II-E - Une directive élément

Une autre possibilité intéressante est de pouvoir créer une directive pour avoir une nouvelle balise personnalisée (à la manière de « restrict : 'E' » de AngularJS). Voici un exemple :

<div id="tuto">
<titre>Mon titre</titre>
</div>

La balise <titre> n'existe pas dans le HTML, on la crée avec ce code :

1. new Vue({

2. el: '#tuto',

3. elementDirectives: {

4. titre: {

5. bind: function() {

6. this.el.innerHTML = '<h1>' + this.el.innerHTML + '</h1>';

7. this.el.style.color = 'Blue';

8. }

9. }

10. }

11. });

La propriété ne s'appelle plus « directives », mais « elementDirectives ». On peut juste utiliser le bind pour définir la balise. Ici je me suis contenté de mettre le texte dans une balise h1 et de changer la couleur :

On dispose en fait de peu de possibilités :

En fait, on peut seulement accéder à l'élément.

II-F - Le panier

Reprenons l'exemple du panier en utilisant une directive personnalisée. Voici le nouveau code de la page :

1. <!DOCTYPE html>

2. <html lang="fr">

4. <head>

5. <meta charset="utf-8">

6. <meta http-equiv="X-UA-Compatible" content="IE=edge">

7. <meta name="viewport" content="width=device-width, initial-scale=1">

8. <title>Test vue.js</title>

9. <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css">

10. <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.3.0/css/font-awesome.min.css">

11. </head>

13. <body>

15. <div class="container" id="tuto">

16. <br>

18. <div class="panel panel-primary">

19. <div class="panel-heading">Panier</div>

20. <table class="table table-bordered table-striped">

21. <thead>

22. <tr>

23. <th class="col-sm-4">Article</th>

24. <th class="col-sm-2">Quantité</th>

25. <th class="col-sm-2">Prix</th>

26. <th class="col-sm-2">Total</th>

27. <th class="col-sm-1"></th>

28. <th class="col-sm-1"></th>

29. </tr>

30. </thead>

31. <tbody>

32. <tr v-for="item in panier">

33. <td>{{ item.article | capitalize }}</td>

34. <td>{{ item.quantite }}</td>

35. <td>{{ item.prix | devise '€' }}</td>

36. <td>{{ item.quantite * item.prix | devise '€' }}</td>

37. <td><button class="btn btn-info btn-block" v-on:click="modifier($index)"><i class="fa fa-edit fa-lg"></button></td>

38. <td><button class="btn btn-danger btn-block" v-on:click="supprimer($index)"><i class="fa fa-trash-o fa-lg"></i></button></td>

39. </tr>

40. <tr>

41. <td colspan="3"></td>

42. <td><strong>{{ total | devise '€' }}</strong></td>

43. <td colspan="2"></td>

44. </tr>

45. <tr>

46. <td><input type="text" class="form-control" v-model="input.article | capitalize" v-el:modif placeholder="Article"></td>

47. <td><input type="text" class="form-control" v-model="input.quantite | entier 10" placeholder="Quantité"></td>

48. <td><input type="text" class="form-control" v-model="input.prix | flottant" placeholder="Prix"></td>

49. <td colspan="3"><btn_ajouter></btn_ajouter></td>

50. </tr>

51. </tbody>

52. </table>

53. </div>

55. </div>

57. <script src="http://cdn.jsdelivr.net/vue/1.0.10/vue.min.js"></script>

59. <script>

61. new Vue({

62. el: '#tuto',

63. data: {

64. panier: [

65. { article: "cahier", quantite: 2, prix: 5.30 },

66. { article: "crayon", quantite: 4, prix: 1.10 },

67. { article: "gomme", quantite: 1, prix: 3.25 }

68. ],

69. input: { article: '', quantite: 0, prix: 0 }

70. },

71. computed: {

72. total: function () {

73. var total = 0;

74. this.panier.forEach(function(el) {

75. total += el.prix * el.quantite;

76. });

77. return total;

78. }

79. },

80. methods: {

81. ajouter: function() {

82. this.panier.push(this.input);

83. this.input = { article: '', quantite: 0, prix: 0 };

84. },

85. modifier: function(index) {

86. this.input = this.panier[index];

87. this.panier.splice(index, 1);

88. this.$$.modif.focus();

89. },

90. supprimer: function(index) {

91. this.panier.splice(index, 1);

92. },

93. },

94. filters: {

95. devise: function(valeur, symbole) {

96. return valeur + ' ' + symbole;

97. },

98. entier: {

99. read: function(valeur) {

100. return valeur;

101. },

102. write: function(nouvelleValeur, ancienneValeur, max) {

103. var valeur = parseInt(nouvelleValeur);

104. if(valeur % 1 === 0) {

105. return valeur > max ? ancienneValeur : valeur;

106. }

107. return 0;

108. }

109. },

110. flottant: {

111. read: function(valeur) {

112. return valeur;

113. },

114. write: function(nouvelleValeur, ancienneValeur) {

115. return isNaN(nouvelleValeur) ? ancienneValeur : nouvelleValeur;

116. }

117. }

118. },

119. elementDirectives: {

120. btn_ajouter: {

121. bind: function() {

122. this.el.innerHTML = '<button class="btn btn-primary btn-block">Ajouter</button>';

123. this.el.addEventListener('click', function(e) {

124. this.vm.ajouter();

125. }.bind(this));

126. }

127. }

128. }

129. });

131. </script>

133. </body>

135. </html>

Vous pouvez voir dans le HTML une nouvelle balise :

<td colspan="3">
<btn_ajouter></btn_ajouter>
</td>

C'est une directive « élément » qui est définie dans cette partie du code JavaScript :

1. elementDirectives: {

2. btn_ajouter: {

3. bind: function() {

4. this.el.innerHTML = '<button class="btn btn-primary btn-block">Ajouter</button>';

5. this.el.addEventListener('click', function(e) {

6. this.vm.ajouter();

7. }.bind(this));

8. }

9. }

10. }

On définit le contenu HTML et on ajoute l'événement pour le clic sur le bouton en appelant dans ce cas la méthode ajouter.

II-G - En résumé

- Vue.js est équipé de nombreuses directives prédéfinies.

- On peut créer une directive personnalisée.

- On peut transmettre un littéral dynamique dans une directive.

- On peut utiliser un ou plusieurs arguments dans une directive.

- On peut créer une directive « élément ».

III - Créer un composant

Vous connaissez peut-être les Web Components. C'est un nouveau standard qui permet d'enrichir le HTML de façon modulaire. En gros, on peut créer une entité qui utilise des éléments HTML et des fonctionnalités propres, le tout facile à intégrer avec une simple balise personnalisée. On peut espérer que ce standard réduira la prolifération des widgets JavaScript et engendrera une certaine homogénéité. Ce qui est certain c'est que le HTML est plutôt limité et ne propose que des éléments simples, on aimerait disposer d'info-bulles, de menus… Mais on est encore loin du but, vous pouvez lire cet excellent article qui résume la situation.

On va voir dans ce chapitre que vue.js propose une approche simple et efficace très fortement inspirée de polymer avec comme grande différence qu'au niveau de la machinerie, il est fait appel exclusivement aux dernières possibilités des web components, ce qui améliore les performances.

III-A - Mon premier composant

Alors on se lance et on crée un petit composant. Au niveau du JavaScript c'est tout simple :

Vue.component('mon-composant', {
template: '<p>Mon premier composant !</p>'
});

La méthode component crée le composant dont on précise le nom (mon-composant) et le template. C'est vraiment le minimum pour un composant ! Il faut aussi initialiser la VueModèle comme d'habitude :

new Vue({
el: '#tuto'
});

Ensuite, on utilise la balise personnalisée dans le HTML :

<div id="tuto">
<mon-composant></mon-composant>
</div>

Avec ce résultat :

Mon premier composant !

Bon pour le moment c'est très simple et on a vu qu'on pouvait réaliser cela dans le précédent chapitre avec une directive élément. Mais on va voir que les composants vont bien plus loin !

Une petite illustration du fonctionnement :

J'ai déclaré le composant de façon globale, mais on pourrait aussi le créer propre à la VueModèle avec la propriété components :

1. new Vue({

2. el: '#tuto',

3. components: {

4. 'mon-composant': {

5. template: '<p>Mon premier composant !</p>'

6. }

7. }

8. });

La méthode component est un raccourci qui étend la bibliothèque et enregistre le composant. La syntaxe développée est :

1. var MonComposant = Vue.extend({

2. template: '<p>Mon premier composant !</p>'

3. });

5. Vue.component('mon-composant', MonComposant);

III-B - Passage de données

III-B-1 - Passage d'une valeur

Créer un composant c'est bien, mais tout ce qui se trouve à l'intérieur est isolé du reste du monde. Autrement dit le composant n'a accès à aucune donnée en dehors des siennes. Il arrive souvent qu'on ait besoin de transmettre des informations pour renseigner le composant. Voyons comment réaliser cela. On va ajouter une propriété au composant :

1. Vue.component('nom', {

2. props: ['nom'],

3. template: '<p>Mon nom est {{nom}}</p>'

4. });

Les props sont des champs pour lesquels le composant attend des valeurs. C'est un tableau, ici on a juste prévu la clé nom. Il ne reste plus qu'à renseigner cette clé dans le HTML :

<div id="tuto">
<nom nom="Toto"></nom>
</div>

Ce qui donne finalement :

Mon nom est Toto

Voici une schématisation du fonctionnement :

III-B-2 - camelCase

Les attributs HTML ne sont pas sensibles à la casse, majuscules ou minuscules ils digèrent tout ça indifféremment. Cela peut être un piège si vous utilisez la notation camelCase. Par exemple vous créez ce composant :

1. Vue.component('nom', {

2. props: ['monNom'],

3. template: '<p>Mon nom est {{monNom}}</p>'

4. });

Et vous utilisez ce HTML :

<nom monNom='Toto'></nom>

Mais tout ce que vous obtenez est :

Mon nom est

Pour obtenir le bon résultat, il faut utiliser l'équivalent avec trait d'union (hyphenated) :

<nom mon-nom="Toto"></nom>

Vous obtenez bien alors :

Mon nom est Toto

III-B-3 - Attribut dynamique

Un attribut statique c'est bien, mais un dynamique c'est encore mieux. On voudrait par exemple entrer le nom dans une zone de texte et qu'il s'affiche avec le composant. Essayons avec ce HTML :

1. <div id="tuto">

2. <input v-model="nomSaisi">

3. <br>

4. <nom v-bind:nom="nomSaisi"></nom>

5. </div>

On prévoit l'argument nom pour le composant avec la directive v-bind, une propriété liée nomSaisi pour la VueModèle.

Avec ce JavaScript :

1. Vue.component('nom', {

2. props: ['nom'],

3. template: '<p>Mon nom est <strong>{{nom}}</strong></p>'

4. });

6. new Vue({

7. el: '#tuto'

8. });

Avec ce résultat :

On retrouve en fait les possibilités qu'on avait déjà rencontrées, mais adaptées à un composant.

Notez la possibilité d'avoir une syntaxe raccourcie :

<nom :nom="nomSaisi"></nom>

III-C - Gestion des listes

Une action très fréquente consiste à générer une liste de données, on a déjà eu l'occasion d'utiliser la directive v-for pour le réaliser. Est-ce que ça peut fonctionner avec un composant ? Voici un exemple :

<div id="tuto">
<liste v-for="personne in personnes" v-bind:personne="personne"></liste>
</div>

Et le JavaScript :

1. new Vue({

2. el: '#tuto',

3. data: {

4. personnes: [

5. {nom: "Durand", prenom: "Jacques"},

6. {nom: "Dupont", prenom: "Albert"},

7. {nom: "Martin", prenom: "Denis"},

8. ]

9. },

10. components: {

11. 'liste': {

12. props: ['personne'],

13. template: '<li>{{personne.nom}} {{personne.prenom}}</li>'

14. }

15. }

16. });

Avec ce résultat :

Pour chaque élément de la liste, une instance du composant est créée, comme on pouvait logiquement s'y attendre. Notez que les données ne sont pas automatiquement envoyées dans le composant qui est parfaitement isolé. Il faut encore déclarer une propriété.

On pourrait évidemment là aussi déclarer le composant de façon globale avec le même fonctionnement :

1. Vue.component('liste', {

2. props: ['personne'],

3. template: '<li>{{personne.nom}} {{personne.prenom}}</li>'

4. });

6. new Vue({

7. el: '#tuto',

8. data: {

9. personnes: [

10. {nom: "Durand", prenom: "Jacques"},

11. {nom: "Dupont", prenom: "Albert"},

12. {nom: "Martin", prenom: "Denis"},

13. ]

14. }

15. });

Notez aussi dans ce cas la possibilité de la syntaxe raccourcie :

<liste v-for="personne in personnes" :personne="personne"></liste>

III-D - Un tableau

Allons un peu plus loin et créons un composant pour générer un tableau. On veut ce HTML :

<div id="tuto">
<tableau :personnes="personnes"></tableau>
</div>

Donc un composant tableau auquel on transmet les données à afficher. On va conserver les données vues précédemment. Voici le JavaScript :

1. var vm = new Vue({

2. el: '#tuto',

3. data: {

4. personnes: [

5. {nom: "Durand", prenom: "Jacques"},

6. {nom: "Dupont", prenom: "Albert"},

7. {nom: "Martin", prenom: "Denis"},

8. ]

9. },

10. components: {

11. tableau: {

12. props: ['personnes'],

13. template: '<table class="table table-bordered">\n' +

14. '<tr v-for="personne in personnes">\n' +

15. '<td v-text="personne.nom"></td>\n' +

16. '<td v-text="personne.prenom"></td>\n' +

17. '</tr>\n' +

18. '</table>\n'

19. }

20. }

21. });

Avec création du tableau :

On peut répercuter tout changement dans les données au niveau du tableau. Par exemple si vous ajoutez ce code :

setTimeout(function() {
vm.personnes.$set(1, {nom: "Claret", prenom: "Marcel"});
}, 2000);

Au bout de deux secondes, vous allez voir le tableau changer pour cette ligne.

III-E - Un composant générique

Le tableau réalisé ci-dessus est totalement adapté aux données concernées. On pourrait aborder cela d'une façon plus générale et créer un composant réutilisable qui accepterait des noms de colonnes et des données sans nécessairement en connaître le nombre :

1. <div id="tuto">

2. <tableau

3. :colonnes="colonnes"

4. :lignes="personnes">

5. </tableau>

6. </div>

Ici on utilise un composant tableau en lui transmettant les colonnes et les lignes de données.

Voici le JavaScript :

1. Vue.component('tableau', {

2. props: ['colonnes', 'lignes'],

3. template: '<table class="table table-bordered">\n' +

4. '<thead>\n' +

5. '<tr>\n' +

6. '<th v-for="value in colonnes">{{ value }}</th>\n' +

7. '</tr>\n' +

8. '</thead>\n' +

9. '<tr v-for="ligne in lignes">\n' +

10. '<td v-for="value in ligne">{{ value }}</td>\n' +

11. '</tr>\n' +

12. '</table>\n'

13. });

15. new Vue({

16. el: '#tuto',

17. data: {

18. colonnes: ['Nom', 'Prénom'],

19. personnes: [

20. ["Durand", "Jacques"],

21. ["Dupont", "Albert"],

22. ["Martin", "Denis"],

23. ]

24. }

25. });

Et ce résultat :

On constate que maintenant le composant peut resservir dans un autre contexte parce qu'il est codé de façon générique. Remarquez que j'ai également transformé les données des personnes pour les rendre également génériques et ainsi simplifier le codage.

III-F - Un template élégant

Le code ci-dessus est élégant, mis à part la partie template qui fait un peu désordre. Il serait bien de pouvoir définir ce template avec une mise en page du code harmonieuse.

On peut inclure le template dans le HTML avec un attribut un peu particulier de la balise <script> qui permet de définir non pas un script, mais un template. Voici le nouveau HTML intégrant le template :

1. <script type="text/x-template" id="tableau-template">

2. <table class="table table-bordered">

3. <thead>

4. <tr>

5. <th v-for="value in colonnes">

6. {{ value }}

7. </th>

8. </tr>

9. </thead>

10. <tbody>

11. <tr v-for="ligne in lignes">

12. <td v-for="value in ligne">

13. {{ value }}

14. </td>

15. </tr>

16. </tbody>

17. </table>

18. </script>

20. <div id="tuto">

21. <tableau

22. :colonnes="colonnes"

23. :lignes="personnes">

24. </tableau>

25. </div>

Remarquez qu'on a un identifiant (tableau-template) qui va permettre de référencer ce template dans le composant :

1. Vue.component('tableau', {

2. props: ['colonnes', 'lignes'],

3. template: '#tableau-template'

4. });

6. new Vue({

7. el: '#tuto',

8. data: {

9. colonnes: ['Nom', 'Prénom'],

10. personnes: [

11. ["Durand", "Jacques"],

12. ["Dupont", "Albert"],

13. ["Martin", "Denis"],

14. ]

15. }

16. });

Avec évidemment le même résultat que ci-dessus :

Cette fois le code est vraiment propre !

III-G - Le panier revisité

Comme exemple du précédent chapitre sur les directives personnalisées, on a amélioré le panier. Je vous propose de reprendre cet exemple, mais cette fois de créer ce panier sous forme de composant. On va au passage se débarrasser de la directive personnalisée qui n'est plus pertinente, par contre on va voir qu'un composant peut disposer de toutes les propriétés que nous avons rencontrées dans cette série de tutoriels.

Voici le code complet de la page :

1. <!DOCTYPE html>

2. <html lang="fr">

4. <head>

5. <meta charset="utf-8">

6. <meta http-equiv="X-UA-Compatible" content="IE=edge">

7. <meta name="viewport" content="width=device-width, initial-scale=1">

8. <title>Test vue.js</title>

9. <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.5/css/bootstrap.min.css">

10. <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.3.0/css/font-awesome.min.css">

11. </head>

13. <body>

15. <div class="container">

16. <br>

18. <script type="text/x-template" id="panier-template">

19. <div class="panel panel-primary">

20. <div class="panel-heading">Panier</div>

21. <table class="table table-bordered table-striped">

22. <thead>

23. <tr>

24. <th class="col-sm-4">Article</th>

25. <th class="col-sm-2">Quantité</th>

26. <th class="col-sm-2">Prix</th>

27. <th class="col-sm-2">Total</th>

28. <th class="col-sm-1"></th>

29. <th class="col-sm-1"></th>

30. </tr>

31. </thead>

32. <tbody>

33. <tr v-for="item in panier">

34. <td>{{ item.article | capitalize }}</td>

35. <td>{{ item.quantite }}</td>

36. <td>{{ item.prix | devise '€' }}</td>

37. <td>{{ item.quantite * item.prix | devise '€' }}</td>

38. <td><button class="btn btn-info btn-block" v-on:click="modifier($index)"><i class="fa fa-edit fa-lg"></button></td>

39. <td><button class="btn btn-danger btn-block" v-on:click="supprimer($index)"><i class="fa fa-trash-o fa-lg"></i></button></td>

40. </tr>

41. <tr>

42. <td colspan="3"></td>

43. <td><strong>{{ total | devise '€' }}</strong></td>

44. <td colspan="2"></td>

45. </tr>

46. <tr>

47. <td><input type="text" class="form-control" v-model="input.article | capitalize" v-el:modif placeholder="Article"></td>

48. <td><input type="text" class="form-control" v-model="input.quantite | entier 10" placeholder="Quantité"></td>

49. <td><input type="text" class="form-control" v-model="input.prix | flottant" placeholder="Prix"></td>

50. <td colspan="3"><button class="btn btn-primary btn-block" v-on:click="ajouter()">Ajouter</button></td>

51. </tr>

52. </tbody>

53. </table>

54. </div>

55. </script>

57. <div id="tuto">

58. <panier :panier="panier"></panier>

59. </div>

61. </div>

63. <script src="http://cdn.jsdelivr.net/vue/1.0.10/vue.min.js"></script>

65. <script>

67. Vue.component('panier', {

68. props: ['panier'],

69. template: '#panier-template',

70. data: function () {

71. return {

72. input: { article: '', quantite: 0, prix: 0 }

73. }

74. },

75. computed: {

76. total: function () {

77. var total = 0;

78. this.panier.forEach(function(el) {

79. total += el.prix * el.quantite;

80. });

81. return total;

82. }

83. },

84. methods: {

85. ajouter: function() {

86. this.panier.push(this.input);

87. this.input = { article: '', quantite: 0, prix: 0 };

88. },

89. modifier: function(index) {

90. this.input = this.panier[index];

91. this.panier.splice(index, 1);

92. this.$$.modif.focus();

93. },

94. supprimer: function(index) {

95. this.panier.splice(index, 1);

96. },

97. },

98. filters: {

99. devise: function(valeur, symbole) {

100. return valeur + ' ' + symbole;

101. },

102. entier: {

103. read: function(valeur) {

104. return valeur;

105. },

106. write: function(nouvelleValeur, ancienneValeur, max) {

107. var valeur = parseInt(nouvelleValeur);

108. if(valeur % 1 === 0) {

109. return valeur > max ? ancienneValeur : valeur;

110. }

111. return 0;

112. }

113. },

114. flottant: {

115. read: function(valeur) {

116. return valeur;

117. },

118. write: function(nouvelleValeur, ancienneValeur) {

119. return isNaN(nouvelleValeur) ? ancienneValeur : nouvelleValeur;

120. }

121. }

122. }

123. });

125. new Vue({

126. el: '#tuto',

127. data: {

128. panier: [

129. { article: "cahier", quantite: 2, prix: 5.30 },

130. { article: "crayon", quantite: 4, prix: 1.10 },

131. { article: "gomme", quantite: 1, prix: 3.25 }

132. ],

133. }

134. });

136. </script>

138. </body>

140. </html>

Avec évidemment les mêmes rendu et fonctionnement que lors du chapitre précédent :

Vous voyez ainsi qu'il est relativement facile de créer des composants réutilisables !

Vous avez sans doute remarqué que la propriété data du composant comporte une fonction. En effet chaque instance du composant aura ses propres données, il est donc nécessaire de les isoler.

Si vous voulez suivre l'évolution des données lors des manipulations du panier, il suffit d'ajouter cette ligne au HTML :

1. <div id="tuto">

2. <panier :panier="panier"></panier>

3. <pre>{{$data | json}}</pre>

4. </div>

Le filtre json permet d'afficher correctement les données :

Ce chapitre est loin d'épuiser les possibilités des composants, mais vous avez à présent de très bonnes bases. Je vous invite à consulter la documentation et cet excellent exemple pour compléter vos connaissances.

III-H - En résumé

- Vue.js permet la création de composants pour enrichir le HTML.

- Un composant peut utiliser toutes les options existantes (mis à part el).

- Il est possible de passer des données à un composant.

- Un composant peut hériter des données de son parent.

- On peut manipuler des listes avec un composant.

IV - Les extensions

La bibliothèque la mieux dotée nécessite forcément des extensions et Vue.js n'échappe pas à la règle. On a déjà vu qu'il est possible de créer des composants. Vue.js permet l'écriture de plugins et il commence à y en avoir quelques-uns de disponibles. Dans ce chapitre, on va utiliser le plugin vue-resource qui permet de faciliter la communication avec un serveur.

IV-A - Un plugin ?

Un plugin (on dit aussi un greffon parfois pour rester Français) est une source complémentaire qui étend les fonctionnalités globales d'une bibliothèque. La nécessité d'utiliser un plugin pour vue.js peut se détailler en :

- la nécessité de disposer de méthodes globales ;

- la nécessité de disposer de filtres, directives…

- la nécessité de disposer de nouvelles méthodes pour les VueModèles.

Le but du présent chapitre n'est pas de créer un plugin, mais juste d'en utiliser un.

IV-B - Le plugin vue-resource

On trouve ce plugin sur Github :

Ce qui va essentiellement nous intéresser ce sont ces fichiers JavaScript :

De façon classique on dispose d'une version lisible et commentée et d'une autre version minifiée pour alléger le chargement. Si vous voulez effectuer du débogage dans le code, utilisez la première version, sinon adoptez directement la seconde.

Il suffit de télécharger le fichier, de le disposer dans un dossier, et de le référencer correctement dans la page HTML, par exemple :

<script src="js/vue-resource.min.js"></script>

On peut également utiliser des outils pour rassembler les ressources dans un fichier unique si vous voulez optimiser le chargement.

Une autre possibilité est d'utiliser un CDN :

<script src="https://cdnjs.cloudflare.com/ajax/libs/vue-resource/0.7.0/vue-resource.min.js"></script>

Ce plugin offre deux services :

1. Un simple service HTTP avec ces méthodes :

- get(url, [data], [success], [options]),

- post(url, [data], [success], [options]),

- put(url, [data], [success], [options]),

- patch(url, [data], [success], [options]),

- delete(url, [data], [success], [options]),

- jsonp(url, [data], [success], [options]) ;

2. Un service de ressource avec une seule méthode pour créer toutes les possibilités :

- resource(url, [params], [actions], [options]).

Ce qui a pour effet de générer ces méthodes :

- get: {method: 'GET'} ;

- save: {method: 'POST'} ;

- query: {method: 'GET'} ;

- update: {method: 'PUT'} ;

- remove: {method: 'DELETE'} ;

- delete: {method: 'DELETE'}.

On a donc tout ce qui est nécessaire pour dialoguer facilement avec un serveur. Dans ce chapitre, on va utiliser le second service.

IV-C - Une API

IV-C-1 - Un serveur de développement

Pour nos tests on a besoin d'un serveur qui réponde aux requêtes en offrant les services d'une API.

Nos besoins vont être une API répondant à L'URL « /noms » avec ces trois routes :

- GET pour récupérer tous les noms ;

- POST pour ajouter un nom ;

- DELETE pour supprimer un nom avec l'identifiant en paramètre.

Pour ne pas trop charger le code, je ne prévois pas la modification du nom. Le but de ce chapitre n'étant pas consacré aux scripts côté serveur, on va se contenter de mettre en place quelque chose de simple. Si vous savez déjà comment réaliser cela, par exemple en utilisant Lumen, vous pouvez sauter cette partie (arrangez-vous toutefois pour adapter les données transmises au code JavaScript utilisé).

Il vous faut un serveur local genre WAMP ou autre. PHP dispose aussi maintenant en interne d'un serveur simplifié parfaitement adapté au développement.

Créez un dossier sur votre serveur pour les tests pour ce cours. Par exemple, j'ai personnellement créé www/vuejs/serveur pour créer les codes de ce chapitre.

IV-C-2 - Composer

Composer est un gestionnaire de dépendances pour PHP. On lui dit quels composants on désire et lui se fait un plaisir de les installer pour nous. En plus il met en place un chargement automatique des classes concernées. Et pour clôturer la chose, il assure aussi les mises à jour !

Si vous ne disposez pas de Composer sur votre machine, c'est le moment de l'installer. Le plus simple est de le placer globalement, référez-vous à ces instructions d'installation qui dépendent de votre système d'exploitation. Si vous ne désirez pas cette installation globale, vous pouvez tout simplement utiliser le fichier phar. Il suffit de mettre ce fichier dans votre dossier sur le serveur !

IV-C-2-a - On crée notre application côté serveur

Vous avez à présent tout ce qu'il faut pour créer l'application côté serveur. Ouvrez votre console et positionnez-vous dans le dossier que vous avez créé sur le serveur et entrez cette commande pour installer un routeur :

composer require league/route

Si vous utilisez le fichier phar, il faudra adapter la syntaxe :

php composer.phar require league/route

Vous devriez obtenir quelque chose dans ce genre :

Vous allez trouver plein de choses dans votre dossier :

Je ne rentre pas dans le détail de tout ça, mais maintenant on dispose d'un routeur simple et rapide largement suffisant pour nos tests.

Ce package dispose d'une documentation complète.

Il faut aussi ajouter un fichier .htaccess pour simplifier nos URL :

1. <IfModule mod_rewrite.c>

2. <IfModule mod_negotiation.c>

3. Options -MultiViews

4. </IfModule>

6. RewriteEngine On

8. # Redirect Trailing Slashes...

9. RewriteRule ^(.*)/$ /$1 [L,R=301]

11. # Handle Front Controller...

12. RewriteCond %{REQUEST_FILENAME} !-d

13. RewriteCond %{REQUEST_FILENAME} !-f

14. RewriteRule ^ index.php [L]

15. </IfModule>

Comme on va utiliser un fichier index.php pour récupérer toutes les URL on explique à Apache qu'il doit tout envoyer sur lui. On va d'ailleurs créer ce fichier :

1. <?php

2. use Symfony\Component\HttpFoundation\Request;

3. use Symfony\Component\HttpFoundation\Response;

4. use League\Route\RouteCollection;

6. // Autoload

7. require 'vendor/autoload.php';

9. // Création du routeur

10. $router = new RouteCollection;

12. // Création routes

13. $router->addRoute('GET', '/noms', function (Request $request, Response $response) {

15. $content = json_encode(file('noms.txt', FILE_IGNORE_NEW_LINES));

16. $response->setContent($content);

17. $response->setStatusCode(200);

18. return $response;

20. });

21. $router->addRoute('POST', '/noms', function (Request $request, Response $response) {

23. $data = json_decode($request->getContent(), true);

24. file_put_contents('noms.txt', $data['nom'] . "\n", FILE_APPEND);

25. $response->setStatusCode(200);

26. return $response;

28. });

29. $router->addRoute('DELETE', '/noms', function (Request $request, Response $response) {

31. $index = $_GET['id'];

32. $arr = file('noms.txt');

33. unset($arr[$index]);

34. $fp = fopen('noms.txt', 'w+');

35. foreach($arr as $line) {

36. fwrite($fp,$line);

37. };

38. fclose($fp);

39. $response->setStatusCode(200);

40. return $response;

42. });

44. // On traite la requête

45. $dispatcher = $router->getDispatcher();

46. $request = Request::createFromGlobals();

47. $response = $dispatcher->dispatch($request->getMethod(), $request->getPathInfo());

49. // On renvoie la réponse

50. $response->send();

J'ai prévu un code simplifié que je ne détaillerai pas parce que ce n'est pas l'objet de ce cours.

Il ne nous manque plus qu'un petit fichier texte pour mémoriser les noms (ça sera plus simple que de mettre en œuvre une base de données ). Prévoyez quelques noms au départ :

Dupont
Durand

Nommez ce fichier noms.txt et positionnez-le aussi dans le serveur.

Finalement, vous devez avoir ceci :

Maintenant tout est prêt côté serveur, on va pouvoir revenir à Vue.js côté client…

IV-D - L'application

Voici le code complet de la page :

1. <!DOCTYPE html>

2. <html lang="fr">

4. <head>

5. <meta charset="utf-8">

6. <meta http-equiv="X-UA-Compatible" content="IE=edge">

7. <meta name="viewport" content="width=device-width, initial-scale=1">

8. <title>Test vue.js</title>

9. <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css">

10. <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.3.0/css/font-awesome.min.css">

11. </head>

13. <body>

15. <div class="container">

16. <br>

18. <script type="text/x-template" id="panneau-template">

19. <div class="alert alert-success" v-show="success">

20. <button type="button" class="close" v-on:click="closeSuccess()">

21. <span>×</span>

22. </button>

23. Serveur mis à jour avec succès !

24. </div>

25. <div class="alert alert-danger" v-show="danger">

26. <button type="button" class="close" v-on:click="closeDanger()">

27. <span>×</span>

28. </button>

29. Echec de la communication avec le serveur !

30. </div>

31. <div class="panel panel-primary">

32. <div class="panel-heading">Liste des noms</div>

33. <table class="table table-bordered table-striped">

34. <thead>

35. <tr>

36. <th class="col-sm-10">Nom</th>

37. <th class="col-sm-2"></th>

38. </tr>

39. </thead>

40. <tbody>

41. <tr v-for="nom in noms">

42. <td>{{ nom }}</td>

43. <td><button class="btn btn-warning btn-block" v-on:click="supprimer($index)">Supprimer</button></td>

44. </tr>

45. <tr>

46. <td><input type="text" class="form-control" v-model="inputNom" placeholder="Nom"></td>

47. <td colspan="1"><button class="btn btn-primary btn-block" v-on:click="ajouter()">Ajouter</button></td>

48. </tr>

49. </tbody>

50. </table>

51. </div>

52. </script>

54. <div id="tuto"></div>

56. </div>

58. <script src="http://cdn.jsdelivr.net/vue/1.0.10/vue.min.js"></script>

59. <script src="https://cdnjs.cloudflare.com/ajax/libs/vue-resource/0.1.17/vue-resource.min.js"></script>

61. <script>

63. var resource = null;

65. new Vue({

66. el: '#tuto',

67. data: {

68. noms: [],

69. inputNom: '',

70. success: false,

71. danger: false

72. },

73. template: '#panneau-template',

74. ready: function() {

75. resource = this.$resource('serveur/noms');

76. resource.get(function (data) {

77. this.noms = data;

78. }).error(function () {

79. this.danger = true;

80. })

81. },

82. methods: {

83. ajouter: function() {

84. resource.save({nom: this.inputNom}, function () {

85. this.success = true;

86. this.noms.push(this.inputNom);

87. this.inputNom = '';

88. }).error(function () {

89. this.danger = true;

90. })

91. },

92. supprimer: function(index) {

93. resource.delete({id: index}, function () {

94. this.success = true;

95. this.noms.splice(index, 1);

96. }).error(function () {

97. this.danger = true;

98. })

99. },

100. closeSuccess: function() {

101. this.success = false;

102. },

103. closeDanger: function() {

104. this.danger = false;

105. }

106. }

107. });

109. </script>

111. </body>

113. </html>

Pour que l'application fonctionne, il faut bien référencer l'URL du serveur au niveau de cette ligne :

resource = this.$resource('serveur/noms');

Vous devez adapter l'URL selon la configuration de vos dossiers. Ici j'ai mis le serveur dans un dossier enfant « serveur ».

Au chargement, si tout se passe bien on obtient :

On retrouve les deux noms qu'on a entrés dans le fichier noms.txt dans le serveur (ou ailleurs dans une base de données si vous avez adopté une autre approche pour votre API).

IV-D-1 - Ajouter un nom

On peut ajouter un nom avec la zone de texte prévue, ce nom vient se positionner dans la liste et un message d'information apparaît :

On peut faire disparaître la barre d'information en cliquant sur la petite croix.

Si on regarde dans le fichier noms.txt on trouve bien le nom en fin de liste :

Dupont
Durand
Carlito

IV-D-2 - Supprimer un nom

De la même manière, on peut supprimer un nom :

On a à nouveau la barre d'information et dans le fichier du serveur on a bien la disparition du nom :

Dupont
Carlito

Notre application fonctionne correctement . Il ne nous reste plus qu'à voir tout ça de plus près…

IV-E - Le template

J'ai prévu de référencer le template :

template: '#panneau-template',

C'est plus propre. On retrouve donc ce template dans le flux du HTML, mais il est géré uniquement par JavaScript :

<script type="text/x-template" id="panneau-template">
... Le template ici
</script>

La partie qui concerne la gestion l'affichage des noms correspond à ce que nous avons déjà vu dans ce cours avec des directives v-for, v-model et v-on :

1. <div class="panel panel-primary">

2. <div class="panel-heading">Liste des noms</div>

3. <table class="table table-bordered table-striped">

4. <thead>

5. <tr>

6. <th class="col-sm-10">Nom</th>

7. <th class="col-sm-2"></th>

8. </tr>

9. </thead>

10. <tbody>

11. <tr v-for="nom in noms">

12. <td>{{ nom }}</td>

13. <td><button class="btn btn-warning btn-block" v-on:click="supprimer($index)">Supprimer</button></td>

14. </tr>

15. <tr>

16. <td><input type="text" class="form-control" v-model="inputNom" placeholder="Nom"></td>

17. <td colspan="1"><button class="btn btn-primary btn-block" v-on:click="ajouter()">Ajouter</button></td>

18. </tr>

19. </tbody>

20. </table>

21. </div>

Pour les barres d'information, on a du code classique de Bootstrap :

1. <div class="alert alert-success" v-show="success">

2. <button type="button" class="close" v-on:click="closeSuccess()">

3. <span>×</span>

4. </button>

5. Serveur mis à jour avec succès !

6. </div>

7. <div class="alert alert-danger" v-show="danger">

8. <button type="button" class="close" v-on:click="closeDanger()">

9. <span>×</span>

10. </button>

11. Echec de la communication avec le serveur !

12. </div>

Par contre, on n'utilise pas la bibliothèque JavaScript de Bootstrap pour le bouton de fermeture puisqu'on dispose déjà de vue.js qui nous offre des possibilités plus larges. C'est pour cette raison que j'ai prévu la directive v-on pour appeler une méthode de la VueModèle pour gérer la visibilité des barres.

IV-F - La ressource

Pour mettre en place le service de ressource et demander au serveur la liste de noms, on a ce code :

1. ready: function() {

2. resource = this.$resource('serveur/noms');

3. resource.get(function (data) {

4. this.noms = data;

5. }).error(function () {

6. this.danger = true;

7. })

8. },

Nous n'avions pas encore rencontré la fonction ready. Il faut un certain temps pour que la VueModèle soit créée et le template compilé. Avant de communiquer avec le serveur, on va attendre d'être sûr que tout cela est réalisé. Lorsque c'est le cas, vue.js appelle la fonction ready si elle existe. Vous avez toutes les informations concernant le cycle de vie d'une VueModèle dans la documentation.

La première chose qu'on fait est de créer la ressource :

resource = this.$resource('serveur/noms');

On utilise ensuite la méthode get pour créer la requête pour l'API :

1. resource.get(function (data) {

2. this.noms = data;

3. }).error(function () {

4. this.danger = true;

5. })

On dispose ensuite de blocs de code en cas de réussite ou d'échec. À ce stade une requête avec le verbe GET est envoyé à l'API avec l'URL « …/noms ». L'API lit le fichier des noms et renvoie les noms :

["Dupont","Durand"]

Il suffit de renseigner la propriété noms de la VueModèle pour avoir l'affichage des noms :

this.noms = data;

En cas d'échec, on met la propriété danger à true :

this.danger = true;

Dans le template est prévue une directive v-show avec cette propriété :

<div class="alert alert-danger" v-show="danger">

Ce qui permet de gérer simplement son affichage :

Pour cacher la barre, il est fait appel à la méthode closeDanger :

closeDanger: function() {
this.danger = false;
}

IV-G - Ajouter un nom

On a prévu un bouton dans le template pour ajouter un nom :

1. <td colspan="1">

2. <button class="btn btn-primary btn-block" v-on:click="ajouter()">

3. Ajouter

4. </button>

5. </td>

Un clic sur le bouton appelle la méthode ajouter :

1. ajouter: function() {

2. resource.save({nom: this.inputNom}, function () {

3. this.success = true;

4. this.noms.push(this.inputNom);

5. this.inputNom = '';

6. }).error(function () {

7. this.danger = true;

8. })

9. },

Cette fois on utilise la méthode save de la ressource. Le premier paramètre sert à transmettre l'information, en l'occurrence le nom ajouté.

Cette fois, on a un verbe POST avec comme contenu de requête cette information JSON :

{"nom":"Tartine"}

L'API stocke le nom et se contente de renvoyer un statut 200 pour dire que tout s'est bien passé. On met alors la liste et la zone de saisie à jour et la barre d'information de réussite est affichée.

En cas d'échec, on affiche la barre d'erreur comme on l'a vu précédemment.

IV-H - Supprimer un nom

Pour chaque nom on dispose d'un bouton de suppression :

1. <td>

2. <button class="btn btn-warning btn-block" v-on:click="supprimer($index)">

3. Supprimer

4. </button>

5. </td>

On appelle la méthode supprimer en précisant l'index du nom :

1. supprimer: function(index) {

2. resource.delete({id: index}, function () {

3. this.success = true;

4. this.noms.splice(index, 1);

5. }).error(function () {

6. this.danger = true;

7. })

8. },

On transmet cette fois l'identifiant du nom avec une requête DELETE de cette forme : « …/noms?id=2 ». L'API supprime le nom de la liste et renvoie un statut 200. On affiche la barre de réussite et on supprime le nom de la liste.

En cas d'erreur, c'est exactement comme pour le cas de l'ajout d'un nom.

Notre application est évidemment très simple et pourrait être améliorée et complétée sur bien des aspects, mais elle vous donne de bonnes bases pour l'utilisation de ce plugin.

IV-I - En résumé

- Vue.js dispose de quelques plugins et devrait élargir rapidement sa panoplie.

- Le plugin vue-resource permet très simplement d'établir une communication avec un serveur.

- il est facile de mettre en place une application cliente qui fait appel à une API.

V - Remerciements

Nous remercions Maurice Chavelli de nous avoir autorisés à publier ce tutoriel.

Nous tenons également à remercier Winjerome pour la mise au gabarit et Claude Leloup pour la correction orthographique.