Architecture MVC

Cours Angular
Qu'est-ce qu'Angular ?
Angular est un framework de développement d’applications web modernes,
particulièrement utilisé pour créer des applications Single Page Applications (SPA).
• SPA signifie qu’une seule page HTML est servie et les contenus sont
actualisés dynamiquement sans recharger toute la page. Cela permet une
expérience utilisateur fluide, similaire à une application mobile.
• TypeScript est un langage de programmation qui s’appuie sur JavaScript en
ajoutant des fonctionnalités comme les types statiques. Angular utilise
TypeScript, car il améliore la maintenabilité du code et permet d’éviter
certains bugs courants.
• MVVM est un modèle d'architecture où :
o Model : Représente les données et la logique de gestion.
o View : L'interface utilisateur qui affiche les données.
o ViewModel : Lie la logique de l'application à la vue.

Structure d'une Application Angular

Dans Angular, tout projet est organisé autour de trois éléments principaux :
• Modules : Un module regroupe plusieurs composants, services, directives, etc. Le module
principal est souvent appelé AppModule et se trouve dans app.module.ts. D’autres modules
peuvent être créés pour organiser le projet de manière plus logique.
• Composants : Ce sont les blocs de construction de l’interface utilisateur. Un composant est
constitué de :
o Un template HTML (vue).
o Un fichier CSS ou SCSS (style).
o Un fichier TypeScript (logique).
• Services : Ils sont utilisés pour centraliser la logique métier et partager des données entre
plusieurs composants. Les services sont particulièrement utiles pour les appels API, la gestion
de l’état, ou la logique complexe.
 Architecture MVC
Exemple de contenu d'un composant :
import { Component } from '@angular/core';
@Component({
selector: 'app-example',
templateUrl: './example.component.html',
styleUrls: ['./example.component.css']
})
export class ExampleComponent {
title = 'Mon premier composant';
}
• selector : Le sélecteur HTML que vous utiliserez dans votre application (<app-example></app-
example>).
• templateUrl et styleUrls : Lien vers les fichiers HTML et CSS du composant.
• title : Une propriété du composant, utilisée dans le fichier HTML via l'interpolation.

Data Binding (liaison des données)

Angular propose plusieurs méthodes pour lier les données entre le modèle (TypeScript) et la
vue (HTML).

Types de Data Binding

• Interpolation ({{ variable }}) : Permet d’afficher les données du composant dans la vue.

<h1>{{ title }}</h1>

• Property Binding ([property]="expression") : Permet de lier une propriété d’un élément HTML
à une variable.

<img [src]="imageUrl">

• Event Binding ((event)="function()") : Permet de lier des événements DOM (comme un clic) à
une méthode du composant.

<button (click)="onClick()">Cliquez-moi</button>

• Two-Way Binding ([(ngModel)]="variable") : Permet une synchronisation bidirectionnelle

entre le modèle et la vue.

<input [(ngModel)]="name">

<p>Bonjour, {{ name }}</p>

 Architecture MVC

Directives Angular

Les directives modifient le DOM. Il existe deux types de directives :

• Directives structurelles : Modifient la structure du DOM (*ngIf, *ngFor).

• Directives d'attributs : Modifient l'apparence ou le comportement des éléments
(ngClass, ngStyle).

➢ Les directives structurelles modifient la structure du DOM en ajoutant ou supprimant

des éléments.

*ngIf : Permet d’afficher ou de masquer un élément en fonction d’une condition.

<div *ngIf="isVisible">Ceci est visible</div>

*ngFor : Permet de répéter un élément pour chaque élément d'une liste.

<ul>

<li *ngFor="let item of items">{{ item }}</li>

</ul>

➢ Les directives d’attributs changent l’apparence ou le comportement des éléments

existants.

ngClass : Permet de définir dynamiquement des classes CSS

<div [ngClass]="{'active': isActive}">Contenu</div>

ngStyle : Permet de modifier dynamiquement le style CSS.

<div [ngStyle]="{'background-color': isActive ? 'green' : 'red'}">Contenu</div>

 Architecture MVC

Les propriétés d’entrée et de sortie dans Angular permettent la communication

entre un composant parent et un composant enfant. Elles sont essentielles pour passer
des données ou des événements entre ces composants de manière structurée.

Propriété d’entrée (@Input)

Les propriétés d’entrée (ou input properties) permettent à un composant enfant de recevoir des
données d'un composant parent.

Fonctionnement

• Un composant parent transmet des données à un composant enfant en utilisant une liaison
de propriétés.

• Dans le composant enfant, une propriété est marquée avec le décorateur @Input, ce qui
signifie que cette propriété peut être remplie avec des valeurs venant de l'extérieur,
généralement du parent.

Étapes :

1. Dans le composant enfant, vous définissez une propriété avec le décorateur @Input.

2. Dans le template du composant parent, vous transmettez une valeur au composant enfant
via la propriété définie.

Propriété de sortie (@Output)

Les propriétés de sortie (ou output properties) permettent à un composant enfant d'envoyer des
événements au composant parent, souvent en réaction à une action utilisateur (comme un clic sur un
bouton).

Fonctionnement

• Un composant enfant peut émettre un événement pour informer son parent qu'une action a
eu lieu (par exemple, qu'un bouton a été cliqué).

• Cela se fait en utilisant la classe EventEmitter dans le composant enfant et le décorateur

@Output pour marquer la propriété qui émet l'événement.

Étapes :

1. Dans le composant enfant, vous créez une propriété de type EventEmitter marquée avec
@Output.

2. Dans le composant parent, vous écoutez cet événement via la syntaxe de liaison
d’événements (event).
 Architecture MVC

Services et Injection de Dépendances

Les services sont des classes qui contiennent des fonctionnalités réutilisables dans
plusieurs composants. Ils sont souvent utilisés pour gérer des données ou effectuer des appels
API.

Utilisation d’un Service dans un Composant

Pour utiliser un service dans un composant, il faut l’injecter dans le constructeur du

composant grâce au mécanisme d’injection de dépendances d'Angular.
Injection de dépendance signifie que vous n'avez pas à créer manuellement une instance de
classe, Angular s'en charge pour vous.

Routing : Navigation entre les pages

Le système de routage d'Angular permet de naviguer entre différentes pages sans recharger la
page entière. Cela permet de créer des applications SPA.

Utilisation du RouterLink pour la navigation

Pour créer des liens de navigation, vous utilisez l'attribut routerLink dans vos templates HTML.

<nav>

<a routerLink="/home">Accueil</a>

<a routerLink="/about">À propos</a>

</nav>

<router-outlet></router-outlet>

routerLink : Définit l’URL de la route cible.

<router-outlet> : Un espace réservé où Angular injecte le composant correspondant à la route

actuelle.
 Architecture MVC

Gestion des Formulaires

Angular fournit deux approches pour la gestion des formulaires :

1. Formulaires basés sur le template : Ils sont simples à utiliser et dépendent fortement
du HTML.

2. Formulaires réactifs : Ils sont plus puissants et utilisent des objets JavaScript pour
gérer la validation et les données des formulaires.

Formulaires basés sur le template

Utilisez ngModel pour lier les champs de formulaire au modèle.

<form #myForm="ngForm" (ngSubmit)="onSubmit(myForm)">

<label for="nom">Nom</label>

<input id="nom" name="nom" ngModel required>

<label for="email">Email</label>

<input id="email" name="email" ngModel email>

<button type="submit" [disabled]="!myForm.valid">Soumettre</button>

</form>

Formulaires réactifs

Les formulaires réactifs utilisent des objets FormGroup et FormControl.

 Architecture MVC
Les hooks dans Angular, également appelés hooks du cycle de vie des composants,
sont des méthodes spéciales qui permettent aux développeurs d’interagir à différents moments
du cycle de vie d’un composant. Ils permettent de gérer des actions spécifiques avant et après
certains événements du cycle de vie d’un composant, comme sa création, son affichage, ses
modifications, et sa destruction.

Voici une liste des principaux hooks disponibles dans Angular:

• ngOnInit : Initialiser les données du composant ou configurer les services.

ngOnInit(): void {

this.loadData();

• ngOnChanges : Chaque fois qu'une propriété d'entrée change.

ngOnChanges(changes: SimpleChanges): void {

console.log(changes);

• ngDoCheck : À chaque cycle de détection de changement.

ngDoCheck(): void {

console.log('Le cycle de détection des changements est exécuté.');

• ngAfterContentInit : Une seule fois, après l’initialisation du contenu projeté.

ngAfterContentInit(): void {

console.log('Le contenu enfant a été inséré dans la vue.');

}
 Architecture MVC

• ngAfterContentChecked : Après chaque cycle de vérification du contenu

projeté.

ngAfterContentChecked(): void {

console.log('Le contenu projeté a été vérifié.');

• ngAfterViewInit : Une seule fois, après l’initialisation de la vue et des sous-

vues.

ngAfterViewInit(): void {

console.log('La vue et les sous-vues sont initialisées.');

• ngAfterViewChecked : Après chaque cycle de vérification des vues.

ngAfterViewChecked(): void {

console.log('Les vues ont été vérifiées.');

• ngOnDestroy : Juste avant la destruction du composant.

ngOnDestroy(): void {

console.log('Le composant est sur le point d’être détruit.');

this.subscription.unsubscribe(); // Unsubscribe to prevent memory leaks

}
 Architecture MVC

API REST
Angular utilise HttpClient pour communiquer avec des APIs. Vous pouvez envoyer des
requêtes HTTP et récupérer des données en JSON, les transformer et les afficher dans vos
composants.

Importation du module HttpClient

Pour utiliser HttpClient, vous devez l’importer dans votre module principal.

import { HttpClientModule } from '@angular/common/http';

@NgModule({

imports: [HttpClientModule],

})

export class AppModule {}

HttpClient : Utiliser le service HttpClient d'Angular pour effectuer des requêtes HTTP
(GET, POST, PUT, DELETE).

Déploiement d’une Application Angular

Une fois que vous avez terminé de développer votre application, vous pouvez la compiler et la
déployer sur un serveur web.

déploiement :

Compilez l'application en mode production :

ng build --prod

Cela génère des fichiers optimisés dans le dossier dist/.