Apprendre à programmer avec le framework Angular

Vos premiers Components

William KOZA

Suite au tutoriel présentant l'outil en ligne de commande Angular-CLI, vous allez apprendre dans ce cours à manipuler vos premiers components et entrevoir les liens qui peuvent exister entre eux.

Commentez

- Titre : Apprendre à programmer avec le framework Angular

- Auteur : William KOZA

- Parution : 30 novembre 2016

- Mise à jour : 30 novembre 2016

- Public visé :

- Licence : Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 2016 William KOZA. 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. Premier chapitre

- II. Les propriétés templateUrl et styleUrls

- II-A. Imbrication de Components

- III. L'usage du Shadow DOM

- IV. Insérer du contenu dans un Component

I - Premier chapitre

Suite au précédent tutoriel, vous avez pu générer votre premier projet et lancer un serveur HTTP grâce à la commande ng serve. Je vous propose maintenant d'étudier de plus près notre premier component AppComponent présent dans src/app. En voici le code :

1. import { Component } from '@angular/core';

2. @Component({

3. selector: 'app-root',

4. templateUrl: './app.component.html',

5. styleUrls: ['./app.component.css']

6. })

7. export class AppComponent {

8. title = 'app works!';

9. }

Le selector est préfixé par app par défaut. Il est possible de changer ce prefix lors de la génération du projet en ajoutant -prefix <nom du préfixe> comme ceci :

II - Les propriétés templateUrl et styleUrls

Angular-CLI a pris le parti d'utiliser la propriété templateUrl pour gérer la partie template de @Component. Cela a pour avantage de dissocier le code du template, mais il est possible de choisir la propriété template à la place. Dans ce cas, le code HTML du component se trouvera dans le décorateur @Component. Si votre template a besoin de plusieurs lignes pour plus de lisibilité, vous pouvez encadrer votre template par les caractères ``. Nous allons donc en profiter pour modifier notre Component en supprimant le fichier app.component.html et en modifiant le code comme ceci :

1. import { Component } from '@angular/core';

2. @Component({

3. selector: 'app-root',

4. template: `

5. <h1>Mon premier Component</h1>

6. <p>en action</p>

7. `,

8. styleUrls: ['./app.component.css']

9. })

10. export class AppComponent {

12. }

Cela nous donne le résultat suivant :

Pour rappel, le fichier HTML généré par Angular-CLI est celui-ci :

1. <!doctype html>

2. <html>

3. <head>

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

5. <title>MonPremierProjet</title>

6. <base href="/">

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

8. <link rel="icon" type="image/x-icon" href="favicon.ico">

9. </head>

10. <body>

11. <app-root>Loading...</app-root>

12. </body>

13. </html>

De la même façon, nous pouvons supprimer le fichier app.component.css et remplacer stylesUrl par la propriété styles. Le fichier app.component.css ne contenait pas de styles, mais nous allons en profiter pour corriger cela avec un peu de rouge :

1. import { Component } from '@angular/core';

3. @Component({

4. selector: 'app-root',

5. template: `

6. <h1>Mon premier Component</h1>

7. <p>en action</p>

8. `,

9. styles: [`

10. h1 {

11. color: red;

12. }

13. `]

14. })

15. export class AppComponent {

17. }

Cela va nous donner :

II-A - Imbrication de Components

Lors de vos développements futurs, vous aurez souvent besoin d'imbriquer vos Components dans d'autres Components. Une application classique Angular peut ressembler à ceci :

Notre AppComponent intègre plusieurs Components tels que les menus, le body, qui à leur tour peuvent en intégrer d'autres. Pour illustrer cela, nous allons créer un nouveau Component child à l'aide d'Angular-CLI, et en se plaçant à la racine du projet, avec la commande suivante :

Le Component, ainsi généré, peut être modifié comme ceci :

1. import { Component} from '@angular/core';

3. @Component({

4. selector: 'app-child',

5. template: `

6. <h1>Mon second Component</h1>

7. `,

8. styles: [`

9. h1 {

10. color : blue;

11. }

12. `]

13. })

14. export class ChildComponent {

16. }

Nous allons maintenant inclure ce Component dans notre premier Component. Pour cela, il suffit d'ajouter notre balise <app-child> dans le template du Component appComponent. Plutôt simple, non ?

1. import {Component} from '@angular/core';

3. @Component({

4. selector: 'app-root',

5. template: `

6. <h1>Mon premier Component</h1>

7. <app-child></app-child>

8. `,

9. styles: [`

10. h1 {

11. color : red;

12. }

13. `]

14. })

15. export class AppComponent {

16. title = 'app works!';

17. }

Le résultat est étonnant !

III - L'usage du Shadow DOM

Pourquoi étonnant ? Regardez les styles CSS de ces deux composants : ils indiquent tous les deux la couleur du même élément HTML h1. Pourtant, le premier h1 est bien rouge et le second bleu. Cela est dû à la portance d'un Component, pour réaliser ce tour de magie, Angular n'utilise pas le shadow DOM par défaut, mais un comportement bien à lui qui lui permet de rendre étanche entre eux les styles CSS de ses Components. Si l'on regarde de plus près le source généré, on peut voir qu'Angular va ajouter des attributs différents aux balises h1 des deux Components pour pouvoir attribuer des styles CSS différents.

Angular propose en fait trois modes d'encapsulation du DOM :

- ViewEncapsulation.None - Ni Shadow DOM, ni aucun mécanisme d'encapsulation de style CSS.

- ViewEncapsulation.Emulated - Pas de Shadow DOM, mais une émulation du Shadow DOM. C'est le comportement par défaut.

- ViewEncapsulation.Native - Utilisation du véritable Shadow DOM. Superbe sur Chrome, mais cela s'arrête là pour le moment. Ni Safari, ni Firefox ne supporte ce mécanisme.

1. import {Component, ViewEncapsulation} from '@angular/core';

3. @Component({

4. selector: 'app-root',

5. template: `

6. <h1>Mon premier Component</h1>

7. <app-child></app-child>

8. `,

9. styles: [`

10. h1 {

11. color : red;

12. }

13. `],

14. encapsulation: ViewEncapsulation.Native

15. })

16. export class AppComponent {

17. title = 'app works!';

18. }

Et si l'on regarde maintenant le source généré, on distingue l'apparition d'un mystérieux #shadow-root qui encapsule les Components entre eux :

IV - Insérer du contenu dans un Component

Pour illustrer ce mécanisme, nous allons créer un nouveau Component que nous allons appeler cadre. Pour cela nous allons nous placer dans le répertoire src/app/child :

J'ai utilisé l'option -flat pour indiquer que je désire voir ce nouveau Component dans le répertoire courant.

Maintenant, je vais me servir de ce nouveau component comme un cadre (au sens CSS). Dans ce cadre, je désire mettre le texte de mon choix. Ce texte ne fera donc pas partie du template du Component cadre. Si vous regardez votre fichier index.html, vous pouvez vous rendre compte que votre balise <app-root>contient Loading…, et pourtant, ce Loading… disparait lorsque votre Component est initialisé au profit du contenu du template.

Pour faire cela, Angular nous offre la balise <ng-content>. Cette dernière se place dans le Component cadre dans notre cas, à l'endroit où on accepte de recevoir un contenu externe. Voici notre component cadre modifié pour répondre à notre besoin :

1. import { Component } from '@angular/core';

3. @Component({

4. selector: 'app-cadre',

5. template: `

6. <div class="bordure">

7. <h1>

8. <ng-content></ng-content>

9. </h1>

10. </div>

11. `,

12. styles: [`

13. h1 {

14. color : darkmagenta;

15. }

16. .bordure {

17. border: 1px solid darkmagenta;

18. }

19. `]

20. })

21. export class CadreComponent  {

23. }

et le code de notre AppComponent utilisant ce nouveau Component :

1. import { Component } from '@angular/core';

3. @Component({

4. selector: 'app-root',

5. template: `

6. <h1>Mon premier Component</h1>

7. <app-child></app-child>

8. <app-cadre>un contenu dans mon cadre</app-cadre>

9. `,

10. styles: [`

11. h1 {

12. color: red;

13. }

14. `]

15. })

16. export class AppComponent {

18. }

Le résultat est magnifique ! Nous pouvons envoyer du texte dans un Component :