Skip to content

Angular Aide-mémoire

Framework d'applications web basé sur TypeScript, par Google.

01

Démarrage

Configuration de la CLI et création de projet

L'Angular CLI est l'outil principal de développement. ng new échafaude un projet complet avec routage et styles préconfigurés. Employez ng generate (ng g) pour une création de fichiers cohérente. La CLI gère build, tests et déploiement.

angular
# install Angular CLI globally
npm install -g @angular/cli

# create a new project
ng new my-app --routing --style=scss
cd my-app

# serve the app (default: localhost:4200)
ng serve --open

# generate components, services, etc.
ng generate component components/user-profile
ng g service services/auth
ng g module modules/admin --routing

Aperçu de la structure de projet

Angular impose une structure de dossiers claire. src/app porte tout le code de fonctionnalités. main.ts amorce le composant racine. angular.json configure les options de build, de tests et de serve. Le dossier environments permet d'échanger les URLs d'API par environnement.

angular
my-app/
├── src/
│   ├── app/                 # application code lives here
│   │   ├── app.component.ts
│   │   ├── app.component.html
│   │   └── app.config.ts    # standalone bootstrap config
│   ├── assets/              # static images, fonts
│   ├── environments/        # env-specific values
│   ├── index.html           # main HTML entry
│   ├── main.ts              # bootstrap entry point
│   └── styles.scss          # global styles
├── angular.json             # CLI workspace config
├── package.json
└── tsconfig.json

Servir et construire

ng serve démarre un serveur de dev avec rechargement façon HMR sur le port 4200 par défaut. Les builds de production font du tree-shaking, minifient et hachent les noms de fichiers pour le cache. Employez --stats-json avec webpack-bundle-analyzer pour trouver les dépendances enflées. ng test lance Karma par défaut.

angular
# dev server with live reload
ng serve --port 4300 --open

# production build (outputs to dist/)
ng build --configuration production

# analyze bundle size
ng build --stats-json
npx webpack-bundle-analyzer dist/my-app/stats.json

# run unit tests (Karma + Jasmine)
ng test

# run end-to-end tests
ng e2e

Générer du code (Schematics)

Les schematics garantissent un nommage et un code passe-partout cohérents. Le flag --standalone génère des composants standalone (recommandé depuis la v17). --route + --module câble automatiquement une route à chargement paresseux. Les guards créés avec --functional renvoient une fonction au lieu d'une classe.

angular
# generate a standalone component
ng g component user-profile --standalone

# generate a service with root provider
ng g service services/auth

# generate a guard (functional by default)
ng g guard guards/auth --functional

# generate a pipe, directive, or module
ng g pipe pipes/shorten
ng g directive directives/highlight
ng g module admin --routing --route admin --module app

# generate an interface or enum
ng g interface models/user
ng g enum models/role

Configuration (angular.json)

angular.json est la config de l'espace de travail. Chaque projet a des cibles build, serve, test et lint. budgets avertit ou échoue quand les bundles dépassent les seuils. Le tableau polyfills inclut zone.js requis par Angular. Plusieurs projets (app + bibliothèque) peuvent coexister dans un même espace de travail.

angular
{
  "projects": {
    "my-app": {
      "architect": {
        "build": {
          "options": {
            "outputPath": "dist/my-app",
            "index": "src/index.html",
            "main": "src/main.ts",
            "polyfills": ["zone.js"],
            "tsConfig": "tsconfig.app.json",
            "assets": ["src/favicon.ico", "src/assets"],
            "styles": ["src/styles.scss"],
            "scripts": []
          },
          "configurations": {
            "production": {
              "budgets": [{ "type": "initial", "maximumWarning": "500kb" }]
            }
          }
        }
      }
    }
  }
}

Environnements

Angular échange les fichiers d'environnement pendant le build selon la configuration (dev vs prod). Les remplacements de fichiers se configurent dans angular.json sous fileReplacements. Injectez l'objet environment n'importe où pour accéder aux valeurs propres à l'env sans URLs codées en dur. Ne commitez jamais de vrais secrets.

angular
// src/environments/environment.ts
export const environment = {
  production: false,
  apiUrl: 'http://localhost:3000/api',
  apiKey: 'dev-key'
};

// src/environments/environment.prod.ts
export const environment = {
  production: true,
  apiUrl: 'https://api.example.com',
  apiKey: 'prod-key'
};

// usage in a service
import { environment } from '../environments/environment';

@Injectable({ providedIn: 'root' })
export class ApiService {
  private baseUrl = environment.apiUrl;
}
02

Bases des composants

Composant de base

Un composant est une classe TypeScript décorée de @Component. selector est la balise HTML personnalisée employée dans les templates. templateUrl/styleUrls pointent vers des fichiers externes ; employez template/styles pour l'inline. @Input marque les propriétés auxquelles les parents peuvent se lier. Gardez les composants centrés sur une seule responsabilité.

angular
// user-profile.component.ts
import { Component, Input } from '@angular/core';

@Component({
  selector: 'app-user-profile',
  templateUrl: './user-profile.component.html',
  styleUrls: ['./user-profile.component.scss'],
})
export class UserProfileComponent {
  @Input() name = 'Guest';
  @Input() age = 0;

  greet() {
    return `Hello, ${this.name}!`;
  }
}

Composant à template inline

Les templates inline sont commodes pour les petits composants et évitent des fichiers supplémentaires. Employez les backticks pour les chaînes multi-lignes — échappez les backticks internes en \`. styles accepte un tableau de chaînes CSS. Le sélecteur :host vise l'élément propre du composant. Passez aux fichiers externes dès qu'un template dépasse ~10 lignes.

angular
@Component({
  selector: 'app-counter',
  template: `
    <button (click)="decrement()">-</button>
    <span>{{ count }}</span>
    <button (click)="increment()">+</button>
  `,
  styles: [`
    :host { display: flex; gap: 8px; align-items: center; }
    button { padding: 4px 12px; }
  `],
})
export class CounterComponent {
  count = 0;
  increment() { this.count++; }
  decrement() { this.count--; }
}

Composant standalone (v14+)

Les composants standalone n'exigent pas de NgModule — ils déclarent leur propre tableau imports listant les dépendances (CommonModule, FormsModule, autres composants). C'est l'approche moderne recommandée. N'importez que ce que vous employez pour un meilleur tree-shaking. Amorcez les composants standalone directement dans main.ts.

angular
import { Component } from '@angular/core';
import { CommonModule } from '@angular/common';
import { FormsModule } from '@angular/forms';

@Component({
  selector: 'app-search',
  standalone: true,
  imports: [CommonModule, FormsModule],
  template: `
    <input [(ngModel)]="query" placeholder="Search..." />
    <p>Searching for: {{ query }}</p>
  `,
})
export class SearchComponent {
  query = '';
}

Inputs et Outputs

@Input laisse les parents passer des données via des liaisons de propriété. @Output expose un EventEmitter auquel les parents s'abonnent via des liaisons d'événement. Initialisez toujours les inputs avec des défauts pour éviter les erreurs undefined. Employez la nouvelle API de signaux input()/output() pour un code plus propre en v17+.

angular
@Component({
  selector: 'app-toggle',
  template: `
    <button (click)="toggle()">{{ label }}: {{ on ? 'On' : 'Off' }}</button>
  `,
})
export class ToggleComponent {
  @Input() label = 'Toggle';
  @Input() on = false;
  @Output() changed = new EventEmitter<boolean>();

  toggle() {
    this.on = !this.on;
    this.changed.emit(this.on);
  }
}

<!-- parent template -->
<app-toggle [label]="'Power'" [on]="isOn" (changed)="onToggle($event)" />

Inputs à signaux (v17.1+)

La fonction input() crée un input à signal, en lecture seule, qu'on appelle comme une fonction. Elle gère les inputs requis via input.required<T>(), les transformations, et s'accorde sans couture à computed() et effect(). output() est le remplaçant moderne de @Output EventEmitter. C'est l'avenir des API de composants Angular.

angular
import { Component, input, output } from '@angular/core';

@Component({
  selector: 'app-card',
  template: `
    <div>{{ title() }} - {{ count() }}</div>
    <button (click)="clicked.emit()">Click</button>
  `,
})
export class CardComponent {
  // readonly signal inputs with defaults
  title = input<string>('Default');
  count = input<number>(0);

  // output() function replaces @Output
  clicked = output<void>();

  // computed derived from inputs
  // requires import { computed }
  // label = computed(() => this.title().toUpperCase());
}

Encapsulation de vue

Emulated (défaut) ajoute des attributs uniques pour borner les styles au composant sans vrai Shadow DOM. None rend les styles globaux (avec parcimonie). ShadowDom emploie le Shadow DOM natif pour une vraie isolation mais affecte la pénétration des styles et certaines bibliothèques tierces. Restez sur Emulated sauf besoin précis.

angular
@Component({
  selector: 'app-styles',
  template: `<p class="local">Emulated (default)</p>`,
  styles: [`p.local { color: red; }`],
  encapsulation: ViewEncapsulation.Emulated, // default
})
export class StylesComponent {}

// ViewEncapsulation.None    -> styles leak globally
// ViewEncapsulation.ShadowDom -> real Shadow DOM (strong isolation)
// ViewEncapsulation.Emulated -> scoped attributes (default, recommended)
03

Syntaxe de template

Interpolation de texte

Les doubles accolades {{ }} rendent des expressions en texte, échappé HTML. On peut employer la plupart des expressions JS : arithmétique, ternaire, appels de méthodes, accès aux propriétés. Pas de new, typeof ni d'opérateurs d'affectation. Les pipes (|) transforment la sortie. L'interpolation se réévalue à chaque cycle de détection de changements.

angular
<p>{{ title }}</p>                       <!-- renders the value -->
<p>{{ 1 + 2 }}</p>                        <!-- expressions allowed -->
<p>{{ user.name }}</p>                    <!-- property access -->
<p>{{ items.length }}</p>                 <!-- method/property -->
<p>{{ price | currency:'USD' }}</p>       <!-- pipe in interpolation -->
<p>{{ isReady ? 'Yes' : 'No' }}</p>       <!-- ternary -->

<!-- one-time interpolation updates when the source changes -->
<!-- new control flow @if, @for work without *ngIf/*ngFor directives -->

Liaison de propriété et d'attribut

[prop] se lie à une propriété DOM (préféré). [attr.name] se lie aux attributs HTML pour les cas sans propriété DOM (colspan, attributs SVG). [class.x] bascule une classe selon la véracité ; [style.prop] règle un style, avec suffixe d'unité optionnel comme .px ou %. Évitez de vous lier à innerHTML avec du contenu non fiable.

angular
<!-- property binding: [prop]="expression" -->
<img [src]="user.avatar" [alt]="user.name" />
<button [disabled]="isSaving">Save</button>
<my-comp [data]="items"></my-comp>

<!-- attribute binding (for attrs without DOM props) -->
<td [attr.colspan]="2">Merged cell</td>
<svg [attr.viewBox]="box"></svg>

<!-- class & style binding -->
<div [class.active]="isActive">Active?</div>
<div [class]="dynamicClassString">
<div [style.color]="colorVar">
<div [style.width.px]="size">Width</div>

Liaison d'événement

(event) se lie aux événements DOM et aux sorties EventEmitter personnalisées. $event est la charge de l'événement (DOM Event pour les natifs, valeur émise pour les personnalisés). Les modificateurs d'événements comme .enter, .esc, .prevent, .stop filtrent ou transforment les événements. La cible entre parenthèses détermine ce qui déclenche le handler.

angular
<button (click)="save()">Save</button>
<input (input)="onInput($event)" (keyup)="onKey($event)" />
<div (mouseenter)="hover=true" (mouseleave)="hover=false">Hover</div>

<!-- $event is the DOM event object -->
<input (keyup.enter)="submit()" (keyup.esc)="cancel()" />

<!-- passive events (scroll, touchmove) -->
<div (scroll.passive)="onScroll($event)">...</div>

<!-- binding to custom component outputs -->
<app-child (changed)="onChanged($event)"></app-child>

Variables de référence de template

Un #var (ou ref-var) référence l'élément DOM ou l'instance de composant sur lequel il est déclaré. Accessible partout dans le template. Pour les composants, la valeur est l'instance ; pour les éléments, l'HTMLElement. Dans @for, $index, $first, $last, $even, $odd sont des variables de contexte implicites.

angular
<input #nameInput type="text" />
<button (click)="nameInput.focus()">Focus</button>
<p>You typed: {{ nameInput.value }}</p>

<!-- ref to a component instance -->
<app-form #f="appForm"></app-form>
<button [disabled]="!f.valid" (click)="f.submit()">Submit</button>

<!-- ref inside @for -->
<ul>
  @for (item of items; track item.id) {
    <li>{{ item.name }} (index: {{ $index }})</li>
  }
</ul>

Liaison bidirectionnelle (banana in a box)

[(ngModel)] exige FormsModule. La syntaxe [(x)] se désugare en [x] + (xChange), donc les liaisons bidirectionnelles personnalisées exigent un input nommé x et un output nommé xChange. Retenez le moyen mnémotechnique « banana in a box » — les parenthèses vont dans les crochets. La fonction de signal model() simplifie cela en v17.2+.

angular
<!-- [()] = "banana in a box" - property + event combined -->
<input [(ngModel)]="username" />

<!-- equivalent to -->
<input [ngModel]="username" (ngModelChange)="username = $event" />

<!-- two-way binding on custom components -->
<app-counter [(value)]="count"></app-counter>
<!-- requires: @Input() value; @Output() valueChange = new EventEmitter() -->

<!-- signals: model() for two-way (v17.2+) -->
// value = model<number>(0);

Navigation sûre et assertion non-null

L'opérateur ?. navigue en sécurité dans les chaînes nullables, renvoyant undefined au lieu de lever. Employez-le pour les données asynchrones pas encore chargées. L'opérateur ! n'est qu'une assertion à la compilation — il n'ajoute pas de vérification à l'exécution, employez-le seulement en étant certain. Pour les tableaux pouvant être null, employez ?? [] comme repli.

angular
<!-- safe navigation: short-circuits to undefined if null -->
<p>{{ user?.profile?.bio }}</p>
<p>{{ user?.getName?.() }}</p>

<!-- non-null assertion: tells compiler it's not null -->
<p>{{ user!.name }}</p>

<!-- in property bindings -->
<img [src]="user?.avatar" />
<app-detail [data]="user!"></app-detail>

<!-- safe navigation in @for doesn't replace track -->
@for (item of items ?? []; track item.id) { ... }
04

Directives

@if / @else (nouveau flux de contrôle)

La nouvelle syntaxe de blocs @if/@else if/@else remplace *ngIf. Pas d'import de CommonModule ni de NgIf, pas d'astérisque, et @else fonctionne nativement (contrairement à l'astuce ng-template de ngIf). C'est la syntaxe recommandée pour le code neuf. Elle fait partie du flux de contrôle intégré introduit en v17 et stable en v18.

angular
@if (user) {
  <p>Hello, {{ user.name }}</p>
} @else if (loading) {
  <p>Loading...</p>
} @else {
  <p>No user found.</p>
}

<!-- no structural directive import needed, no * prefix -->
<!-- works in standalone templates automatically (v17+) -->

@for / @empty (nouveau flux de contrôle)

@for remplace *ngFor avec une expression track obligatoire pour un diffing DOM efficace. @empty rend un contenu de repli quand la collection est vide. Les variables de contexte implicites ($index, $first, $last, etc.) sont toujours disponibles. Suivre par un id unique stable est critique pour la performance avec les grandes listes.

angular
<ul>
  @for (item of items; track item.id) {
    <li>{{ item.name }} ({{ $index }})</li>
  } @empty {
    <li>No items yet.</li>
  }
</ul>

<!-- 'track' is REQUIRED for performance -->
<!-- implicit vars: $index, $first, $last, $even, $odd, $count -->

<!-- @for over a range -->
@for (i of [1,2,3,4,5]; track i) {
  <span>{{ i }}</span>
}

ngClass et ngStyle

ngClass accepte un objet (clés vraies appliquées), un tableau ou une chaîne. ngStyle accepte un objet à clés camelCase ou kebab-case, avec suffixes d'unité optionnels. Exige l'import de CommonModule ou des directives précises. Pour une classe/un style unique, [class.x] et [style.x] sont plus légers et sans import.

angular
<div [ngClass]="{ active: isActive, disabled: !enabled }">Box</div>
<div [ngClass]="['card', 'shadow', themeClass]">Card</div>
<div [ngClass]="currentClass">String</div>

<div [ngStyle]="{ color: textColor, 'font-size.px': size }">Text</div>
<div [ngStyle]="styleObject">Styled</div>

<!-- import CommonModule (or NgClass/NgStyle) for these -->
<!-- prefer [class.x] and [style.x] for single value bindings -->

@switch (nouveau flux de contrôle)

@switch remplace *ngSwitch (et les directives ngSwitchCase/ngSwitchDefault). Plus propre — pas de conteneur englobant, pas d'imports. Chaque @case ne se rend que quand sa valeur matche l'expression du @switch. @default est le repli. C'est le flux de contrôle intégré disponible en v17+.

angular
@switch (status) {
  @case ('loading') {
    <spinner>Loading...</spinner>
  }
  @case ('error') {
    <p class="error">Something went wrong</p>
  }
  @case ('success') {
    <p>Done!</p>
  }
  @default {
    <p>Idle</p>
  }
}

Directive d'attribut personnalisée

Les directives d'attribut changent l'apparence ou le comportement des éléments DOM. Les [crochets] du sélecteur matchent l'usage en attribut. ElementRef donne un accès direct au DOM ; HostListener se lie aux événements DOM. Injectez ElementRef<HTMLElement> pour la sûreté de type. Préférez Renderer2 pour la manipulation du DOM en rendu côté serveur.

angular
import { Directive, ElementRef, Input, HostListener } from '@angular/core';

@Directive({
  selector: '[appHighlight]',
})
export class HighlightDirective {
  @Input('appHighlight') highlightColor = 'yellow';

  constructor(private el: ElementRef<HTMLElement>) {}

  @HostListener('mouseenter') onMouseEnter() {
    this.el.nativeElement.style.backgroundColor = this.highlightColor;
  }

  @HostListener('mouseleave') onMouseLeave() {
    this.el.nativeElement.style.backgroundColor = '';
  }
}

<!-- usage: <p appHighlight="lightblue">Hover me</p> -->

Entrailles des directives structurelles

Les directives structurelles ajoutent/retirent des nœuds DOM via TemplateRef (le template enveloppé) et ViewContainerRef (où insérer). L'astérisque (*) est du sucre qui enveloppe l'élément dans un <ng-template>. Les nouveaux blocs @if/@for/@switch remplacent la plupart des directives structurelles personnalisées, mais ce pattern reste utile pour les cas avancés.

angular
import { Directive, TemplateRef, ViewContainerRef, Input } from '@angular/core';

@Directive({ selector: '[appUnless]' })
export class UnlessDirective {
  private hasView = false;

  @Input() set appUnless(condition: boolean) {
    if (!condition && !this.hasView) {
      this.vc.createEmbeddedView(this.tpl);
      this.hasView = true;
    } else if (condition && this.hasView) {
      this.vc.clear();
      this.hasView = false;
    }
  }

  constructor(private tpl: TemplateRef<unknown>, private vc: ViewContainerRef) {}
}

<!-- usage: <div *appUnless="hide">Shown when hide is false</div> -->
05

Pipes

Pipes intégrés

Les pipes transforment les valeurs affichées dans les templates. Intégrés courants : date, number, currency, percent, uppercase, lowercase, titlecase, slice, json, async. Les pipes sont purs par défaut — ils ne recalculent que quand la référence d'entrée change. Les chaînes de format suivent les règles de locale d'Angular.

angular
<!-- date formatting -->
<p>{{ today | date }}</p>                          <!-- Sep 10, 2024 -->
<p>{{ today | date:'short' }}</p>
<p>{{ today | date:'yyyy-MM-dd HH:mm' }}</p>

<!-- number & currency -->
<p>{{ 3.14159 | number:'1.2-2' }}</p>               <!-- 3.14 -->
<p>{{ price | currency:'USD':'symbol':'1.2-2' }}</p>
<p>{{ ratio | percent }}</p>

<!-- text transforms -->
<p>{{ 'hello world' | uppercase }}</p>              <!-- HELLO WORLD -->
<p>{{ 'HELLO' | lowercase }}</p>
<p>{{ title | titlecase }}</p>
<p>{{ 'a/b/c' | slice:0:2 }}</p>

<!-- json (for debugging) -->
<pre>{{ obj | json }}</pre>

Enchaîner des pipes et paramètres

Les pipes s'enchaînent de gauche à droite, chacun recevant la sortie précédente. Les paramètres se séparent par des deux-points et sont positionnels. Employez-les pour des transformations pures (formatage, filtrage) pour garder les templates déclaratifs. Évitez les pipes impurs pour les données sensibles à la performance ; calculez dans le composant à la place.

angular
<!-- chain: left to right, output of one feeds the next -->
<p>{{ '  hello  ' | trim | uppercase }}</p>         <!-- HELLO -->
<p>{{ birthday | date:'fullDate' | uppercase }}</p>
<p>{{ items | slice:0:3 | json }}</p>

<!-- parameters separated by colons -->
<p>{{ amount | number:'1.2-2':'en-US' }}</p>
<p>{{ meeting | date:'shortTime' }}</p>
<p>{{ list | slice:1:5 }}</p>

<!-- multiple parameters -->
<p>{{ value | myPipe:arg1:arg2:arg3 }}</p>

Pipe personnalisé

Les pipes personnalisés implémentent PipeTransform.transform(). Le nom @Pipe s'emploie dans les templates. Enregistrez les pipes standalone (v15+) dans le tableau imports d'un composant, ou déclarez-les dans un NgModule. Les pipes purs (défaut) ne re-tournent que quand la référence d'entrée change — passez de nouvelles références pour déclencher les mises à jour.

angular
import { Pipe, PipeTransform } from '@angular/core';

@Pipe({ name: 'truncate' })
export class TruncatePipe implements PipeTransform {
  transform(value: string, limit = 20, ellipsis = '...'): string {
    if (!value) return '';
    return value.length > limit
      ? value.slice(0, limit) + ellipsis
      : value;
  }
}

// register in a standalone component imports:
// imports: [TruncatePipe]

<!-- usage -->
<p>{{ longText | truncate:50 }}</p>
<p>{{ longText | truncate:10:'>>' }}</p>

Pipe async

Le pipe async s'abonne à un Observable ou une Promise, rend la valeur et se désabonne automatiquement à la destruction — pas de subscribe/unsubscribe manuel. Combiné à *ngIf as ou @for, il gère proprement le null pendant le chargement. Il marque le composant pour vérification quand une nouvelle valeur arrive, s'intégrant à OnPush.

angular
@Component({
  selector: 'app-user',
  template: `
    <div *ngIf="user$ | async as user">
      {{ user.name }}
    </div>
    <ul>
      @for (item of items$ | async; track item.id) {
        <li>{{ item.name }}</li>
      }
    </ul>
  `,
  imports: [AsyncPipe, NgIf],
})
export class UserComponent {
  user$ = this.http.get<User>('/api/user');
  items$ = this.http.get<Item[]>('/api/items');

  constructor(private http: HttpClient) {}
}

Pipes purs vs impurs

Les pipes purs mettent les résultats en cache jusqu'au changement de référence d'entrée ; muter des tableaux ou objets ne les déclenche pas. Les pipes impurs (pure: false) re-tournent à chaque détection de changements — commode pour filtrer des tableaux mutés mais coûteux. Préférez garder les données immuables (remplacer les tableaux au lieu de les muter) et les pipes purs pour la performance.

angular
// PURE (default): re-runs only when input reference changes
@Pipe({ name: 'filter' })
export class FilterPipe implements PipeTransform {
  transform(items: Item[], term: string): Item[] {
    return items.filter(i => i.name.includes(term));
  }
}
// Issue: mutating items.push() won't trigger re-evaluation.

// IMPURE: re-runs on every change detection cycle
@Pipe({ name: 'filter', pure: false })
export class ImpureFilterPipe implements PipeTransform { ... }
// ⚠️ Expensive! Use sparingly — affects performance.

i18n et pipes de locale

Les pipes comme date, number, currency respectent LOCALE_ID. Enregistrez les données de locale via registerLocaleData avant l'amorçage. Les formats currency/decimal suivent la locale active. Pour les apps multilingues, fournissez LOCALE_ID par utilisateur ou employez l'outillage i18n pour les traductions de templates. Des données de locale manquantes replient vers en-US.

angular
// register locale data in app.config.ts
import { registerLocaleData } from '@angular/common';
import localeFr from '@angular/common/locales/fr';
registerLocaleData(localeFr);

// provide a default locale
providers: [{ provide: LOCALE_ID, useValue: 'fr-FR' }]

// usage - now locale-aware
<p>{{ price | currency:'EUR' }}</p>          <!-- 1 234,56 € -->
<p>{{ today | date:'fullDate' }}</p>          <!-- lundi 10 septembre 2024 -->
<p>{{ number | number:'1.2-2' }}</p>          <!-- 1 234,56 -->
<p>{{ amount | currency:'JPY' }}</p>          <!-- ¥1,235 -->
06

Services et injection de dépendances

Service de base

providedIn: 'root' crée un singleton disponible dans toute l'app sans enregistrement de module. Le service est tree-shakeable — retiré s'il est inutilisé. Employez la fonction inject() (v14+) au lieu de l'injection par constructeur pour un code plus propre et des tests plus faciles. Les services portent l'état partagé et la logique métier ; les composants restent présentationnels.

angular
import { Injectable } from '@angular/core';

@Injectable({ providedIn: 'root' })
export class UserService {
  private users = ['Alice', 'Bob'];

  getUsers() { return this.users; }
  addUser(name: string) { this.users.push(name); }
}

// usage in a component
export class UserListComponent {
  // Angular injects the singleton instance
  constructor(private users: UserService) {}

  get users() { return this.usersService.getUsers(); }
  private usersService = inject(UserService);
}

Fonction inject()

inject() est l'alternative moderne à l'injection par constructeur. Elle fonctionne dans les initialisateurs de champs, rendant le code plus lisible et offrant une meilleure inférence TypeScript. Elle doit tourner pendant la construction (pas dans des callbacks asynchrones ultérieurs). Employez-la de façon cohérente — mélanger paramètres de constructeur et inject() est possible mais inject() est plus propre.

angular
import { Injectable, inject } from '@angular/core';

@Injectable({ providedIn: 'root' })
export class AuthService {
  private http = inject(HttpClient);
  private router = inject(Router);

  login(creds: Credentials) {
    return this.http.post('/api/login', creds);
  }
}

// in a component
export class DashboardComponent {
  private auth = inject(AuthService);
  user = this.auth.currentUser;   // works in field initializers
}

Configuration des providers

Les providers se configurent à tout niveau (root, module, composant). useClass échange les implémentations (parfait pour mocker). useValue fournit des constantes. useExisting aliasse un service vers un autre. useFactory crée des instances dynamiquement. InjectionToken sert aux valeurs non classes comme les chaînes ou objets de config.

angular
@Component({
  // ... provide at component level for instance-per-component
  providers: [
    UserService,                              // shorthand
    { provide: Logger, useClass: ConsoleLogger },
    { provide: API_URL, useValue: 'https://api.example.com' },
    { provide: Storage, useExisting: LocalStorageService },
    {
      provide: Config,
      useFactory: () => new Config(env.production)
    },
  ],
})
export class AdminComponent {}

// InjectionToken for non-class values
export const API_URL = new InjectionToken<string>('API_URL');

Injecteurs hiérarchiques

L'arbre DI d'Angular reflète l'arbre de composants. providedIn: 'root' = une instance pour toute l'app. Les providers au niveau composant créent des injecteurs enfants — chaque instance a les siens. Utile pour les composants avec état comme les éditeurs. 'any' se borne aux modules paresseux. 'platform' est rare, pour les configurations multi-apps.

angular
// root injector (singleton app-wide)
@Injectable({ providedIn: 'root' })
export class AuthService {}

// component-level provider: new instance for this component and children
@Component({
  providers: [UserService],   // each AdminComponent gets its own UserService
})
export class AdminComponent {}

// 'any' creates a lazy singleton per lazy module
@Injectable({ providedIn: 'any' })
export class SharedService {}

// 'platform' shared across all Angular apps on the page
@Injectable({ providedIn: 'platform' })
export class GlobalConfig {}

Multi providers et tokens

multi: true enregistre plusieurs providers sous un même token, injectés en tableau. Utile pour les systèmes de plugins, intercepteurs, validateurs ou toute collection extensible. L'ordre d'injection suit l'ordre d'enregistrement. Combinez avec InjectionToken pour typer le tableau correctement.

angular
// define a token for a list of plugins
export const PLUGIN = new InjectionToken<Plugin>('PLUGIN');

// provide multiple plugins
@Component({
  providers: [
    { provide: PLUGIN, useClass: AuthPlugin, multi: true },
    { provide: PLUGIN, useClass: AnalyticsPlugin, multi: true },
  ],
})
export class AppComponent {}

// inject all of them as an array
export class PluginManager {
  plugins = inject(PLUGIN);   // Plugin[]
}

Providers optionnels et par défaut

@Optional() ou inject(token, { optional: true }) renvoie null si aucun provider n'est trouvé au lieu de lever. Employez-le pour les dépendances non critiques. Autres modificateurs : @SkipSelf() (ne pas vérifier l'injecteur courant), @Self() (seulement le courant), @Host() (jusqu'au composant hôte). Les équivalents inject() acceptent des flags dans l'objet options.

angular
import { Injectable, inject, Optional, Inject } from '@angular/core';

@Injectable({ providedIn: 'root' })
export class Logger {
  constructor(@Optional() @Inject(CONFIG) private cfg?: Config) {
    // cfg is null if no provider exists — handle gracefully
  }
}

// or with inject()
export class Service {
  cfg = inject(CONFIG, { optional: true });   // Config | null
  baseUrl = inject(API_URL, { optional: true }) ?? '/api';
}

// skipSelf: look in parent injectors only
// self: only this component's injector
// host: limit to host component
07

Routage

Configuration des routes

Les routes mappent des chemins d'URL aux composants. loadComponent/loadChildren activent le chargement paresseux (bundle initial plus petit). :id est un paramètre de route. Le joker '**' attrape les URLs non matchées — placez-le en dernier. provideRouter met en place le routeur dans les apps standalone. Réglez title pour les noms d'onglets du navigateur ; chaîne ou ResolveFn.

angular
// app.routes.ts (standalone)
import { Routes } from '@angular/router';

export const routes: Routes = [
  { path: '', component: HomeComponent, title: 'Home' },
  { path: 'about', loadComponent: () => import('./about/about.component')
      .then(m => m.AboutComponent) },
  { path: 'users/:id', component: UserDetailComponent },
  { path: 'admin', loadChildren: () => import('./admin/admin.routes')
      .then(m => m.ADMIN_ROUTES) },
  { path: '**', component: NotFoundComponent },   // wildcard
];

// app.config.ts
export const appConfig: ApplicationConfig = {
  providers: [provideRouter(routes)]
};

Router outlet et liens

router-outlet marque où se rendent les composants routés. routerLink crée des liens de navigation (employez la forme tableau pour les paramètres). routerLinkActive applique une classe quand la route matche. La navigation par programme emploie router.navigate() ou routerLink. Les outlets nommés activent les routes secondaires (ex. une modale à côté de la vue principale).

angular
<!-- app.component.html -->
<nav>
  <a routerLink="/" routerLinkActive="active">Home</a>
  <a routerLink="/about" routerLinkActive="active">About</a>
  <a [routerLink]="['/users', userId]">My Profile</a>
</nav>

<router-outlet></router-outlet>

<!-- named outlet (secondary route) -->
<router-outlet name="popup"></router-outlet>

<!-- navigate programmatically -->
<button (click)="go()">Go</button>
// constructor(private router: Router) {}
// go() { this.router.navigate(['/users', 42]); }

Paramètres de route et de requête

Employez snapshot pour des lectures ponctuelles quand le composant est détruit et recréé à chaque navigation. Employez l'observable param/queryParamMap quand la même instance de composant traite des paramètres différents (ex. naviguer de /users/1 à /users/2). Désabonnez-vous toujours ou employez le pipe async pour éviter les fuites.

angular
// reading route params
export class UserDetailComponent {
  constructor(private route: ActivatedRoute) {
    // snapshot: one-time read (good for static links)
    const id = this.route.snapshot.paramMap.get('id');

    // observable: reacts to param changes (same component reused)
    this.route.paramMap.subscribe(params => {
      console.log(params.get('id'));
    });
  }
}

// query params: /search?q=angular&page=2
this.route.queryParamMap.subscribe(qp => {
  this.q = qp.get('q');
});

<!-- link with query params -->
<a [routerLink]="['/search']" [queryParams]="{ q: 'angular', page: 2 }">

Routes enfants et imbriquées

Les routes enfants se rendent dans un router-outlet imbriqué à l'intérieur du composant parent. redirectTo avec pathMatch: 'full' redirige les chemins enfants vides. Ce pattern bâtit des mises en page maître-détail (chromatique parent, contenu enfant). Chaque niveau d'imbrication exige son propre router-outlet dans le template du parent.

angular
export const routes: Routes = [
  {
    path: 'admin',
    component: AdminLayoutComponent,
    children: [
      { path: '', redirectTo: 'dashboard', pathMatch: 'full' },
      { path: 'dashboard', component: DashboardComponent },
      { path: 'users', component: AdminUsersComponent },
      { path: 'settings', component: SettingsComponent },
    ],
  },
];

<!-- AdminLayoutComponent template -->
<h2>Admin Panel</h2>
<nav>...</nav>
<router-outlet></router-outlet>   <!-- child routes render here -->

Chargement paresseux

Le chargement paresseux découpe l'app en chunks chargés à la demande, réduisant le bundle initial. loadChildren charge un fichier de routes (export par défaut de Routes) ; loadComponent charge un seul composant standalone. La chaîne de dynamic import() doit être un chemin statique pour que le bundler découpe correctement. Employez-le pour les zones de fonctionnalités derrière la navigation.

angular
// main routes - load feature modules on demand
export const routes: Routes = [
  { path: '', component: HomeComponent },
  {
    path: 'admin',
    loadChildren: () => import('./admin/admin.routes').then(m => m.ADMIN_ROUTES),
  },
  {
    path: 'reports',
    loadComponent: () => import('./reports/reports.component')
      .then(m => m.ReportsComponent),
  },
];

// admin.routes.ts
export const ADMIN_ROUTES: Routes = [
  { path: '', component: AdminComponent },
  { path: 'users', component: AdminUsersComponent },
];

Événements du routeur et navigation

Les événements du routeur (NavigationStart, NavigationEnd, GuardsCheckStart, etc.) permettent de suivre le cycle de vie de la navigation. Filtrez toujours vers des événements précis et désabonnez-vous. router.navigate accepte des extras : queryParams, fragment, state (données transitoires hors URL) et replaceUrl. state se lit via router.getCurrentNavigation().extras.state.

angular
// subscribe to router events
export class AppComponent implements OnDestroy {
  private sub = this.router.events.pipe(
    filter((e): e is NavigationEnd => e instanceof NavigationEnd)
  ).subscribe(e => {
    console.log('Navigated to:', e.url);
    this.analytics.track(e.url);
  });

  constructor(private router: Router) {}
  ngOnDestroy() { this.sub.unsubscribe(); }
}

// navigation with extras
this.router.navigate(['/users'], {
  queryParams: { sort: 'name' },
  fragment: 'top',
  state: { from: 'login' },   // passed to next route, not in URL
});
08

Formulaires

Formulaire piloté par le template

Les formulaires pilotés par le template emploient ngModel et des références de template. FormsModule est requise. L'état du formulaire (validité, touched, dirty) se suit via les directives ngForm et ngModel. Idéal pour les formulaires simples. La validation se déclare dans le template (required, minlength, pattern). Accédez à l'état du contrôle via des refs de template comme #e='ngModel'.

angular
import { FormsModule } from '@angular/forms';

@Component({
  selector: 'app-login',
  standalone: true,
  imports: [FormsModule],
  template: `
    <form #f="ngForm" (ngSubmit)="save(f.value)">
      <input name="email" [(ngModel)]="email" required email #e="ngModel" />
      <span *ngIf="e.invalid && e.touched">Email required</span>

      <input name="pwd" type="password" [(ngModel)]="pwd" required minlength="6" />
      <button [disabled]="f.invalid">Submit</button>
    </form>
  `,
})
export class LoginComponent {
  email = '';
  pwd = '';
  save(v: any) { console.log(v); }
}

Configuration des formulaires réactifs

Les formulaires réactifs définissent le modèle dans la classe du composant comme instances FormControl/FormGroup. ReactiveFormsModule est requise. formControlName lie les inputs aux contrôles. Le modèle du formulaire est observable et testable sans le DOM. nonNullable: true prévient les valeurs null quand l'input est vidé. Préféré pour les formulaires complexes.

angular
import { ReactiveFormsModule, FormControl, FormGroup } from '@angular/forms';

@Component({
  selector: 'app-profile',
  imports: [ReactiveFormsModule],
  template: `
    <form [formGroup]="form" (ngSubmit)="save()">
      <input formControlName="name" />
      <input formControlName="email" />
      <button [disabled]="form.invalid">Save</button>
    </form>
    <p>Valid: {{ form.valid }}</p>
  `,
})
export class ProfileComponent {
  form = new FormGroup({
    name: new FormControl('', { nonNullable: true }),
    email: new FormControl('', { nonNullable: true }),
  });
  save() { console.log(this.form.value); }
}

FormBuilder et formulaires typés

FormBuilder réduit le code passe-partout. fb.group() infère les types depuis les défauts. Les groupes imbriqués modélisent les données imbriquées. FormArray gère les listes dynamiques de contrôles. Avec nonNullable, les contrôles gardent leur type déclaré au lieu de null. Employez get() ou controls pour un accès type-safe. Les formulaires typés (v14+) offrent l'autocomplétion et la vérification de type sur value.

angular
import { FormBuilder, FormGroup } from '@angular/forms';

export class CheckoutComponent {
  private fb = inject(FormBuilder);

  // typed form (v14+ nonNullable)
  form = this.fb.group({
    name: ['', { nonNullable: true }],
    address: this.fb.group({
      street: [''],
      city: [''],
      zip: [''],
    }),
    items: this.fb.array<CartItem>([]),
  });

  // type-safe access
  get items() { return this.form.controls.items; }
  addItem(item: CartItem) { this.items.push(this.fb.control(item)); }
}

Validation de formulaire

Validators.required, .minLength, .maxLength, .pattern, .email, .min, .max sont intégrés. Appliquez-en plusieurs via un tableau. La validation inter-champs vit sur le FormGroup avec une fonction validateur recevant tout le groupe. Vérifiez control.touched/dirty avant de montrer les erreurs pour ne pas engueuler les utilisateurs au premier rendu. Employez .hasError('clé') pour tester des erreurs précises.

angular
import { Validators } from '@angular/forms';

// built-in validators
const email = new FormControl('', [
  Validators.required,
  Validators.email,
  Validators.maxLength(100),
]);

const password = new FormControl('', [
  Validators.required,
  Validators.minLength(8),
  Validators.pattern(/[A-Z]/),
]);

// cross-field validation at group level
const form = this.fb.group({
  pwd: ['', Validators.required],
  confirm: ['', Validators.required],
}, { validators: matchPassword });   // custom group validator

// reading state in template
<!-- <span *ngIf="email.touched && email.hasError('required')">Required</span> -->

Validateur personnalisé

Les validateurs personnalisés sont des fonctions renvoyant des ValidationErrors (une map) ou null si valide. Les validateurs asynchrones renvoient un Observable ou une Promise — employez-les pour les vérifications serveur comme la disponibilité d'un nom d'utilisateur. Debouncez toujours les validateurs asynchrones (via timer/switchMap) pour ne pas marteler le serveur à chaque frappe.

angular
import { AbstractControl, ValidationErrors, ValidatorFn } from '@angular/forms';

// function validator
export const matchPassword: ValidatorFn = (group: AbstractControl): ValidationErrors | null => {
  const pwd = group.get('pwd')?.value;
  const confirm = group.get('confirm')?.value;
  return pwd === confirm ? null : { mismatch: true };
};

// async validator (returns Observable/Promise)
export function uniqueUsername(http: HttpClient): AsyncValidatorFn {
  return (control: AbstractControl) => {
    return timer(500).pipe(
      switchMap(() => http.get(`/api/check/${control.value}`)),
      map(exists => exists ? { taken: true } : null),
    );
  };
}

Changements de valeur et état du formulaire

valueChanges et statusChanges sont des Observables qui émettent à chaque saisie. debounceTime prévient le travail excessif lors des frappes rapides. takeUntil avec un Subject est la façon idiomatique de se désabonner à la destruction. patchValue met à jour partiellement les valeurs du formulaire ; setValue exige tous les champs. Employez { emitEvent: false } pour mettre à jour en silence sans déclencher valueChanges.

angular
export class FilterComponent implements OnDestroy {
  private destroy = new Subject<void>();
  form = this.fb.group({ q: [''], category: ['all'] });

  ngOnInit() {
    // react to entire form changes (debounced)
    this.form.valueChanges.pipe(
      debounceTime(300),
      takeUntil(this.destroy),
    ).subscribe(v => this.search(v));

    // react to a single control
    this.form.controls.q.valueChanges.subscribe(q => {
      console.log('q changed:', q);
    });
  }

  ngOnDestroy() { this.destroy.next(); }
}
09

HttpClient

Configuration et GET de base

provideHttpClient() enregistre le client dans toute l'app. Les méthodes HttpClient renvoient des Observables froids — elles ne s'exécutent qu'à l'abonnement (pipe async dans les templates ou subscribe dans les services). Les réponses se typent via génériques. Gérez toujours les erreurs de façon centrale ou par appel. withFetch() (v18) opte pour le backend moderne basé fetch.

angular
// app.config.ts
import { provideHttpClient } from '@angular/common/http';

export const appConfig: ApplicationConfig = {
  providers: [provideHttpClient()],
};

// usage in a service
@Injectable({ providedIn: 'root' })
export class PostService {
  private http = inject(HttpClient);
  private api = 'https://jsonplaceholder.typicode.com/posts';

  getPosts() {
    return this.http.get<Post[]>(this.api);
  }
}

// in a component (use async pipe to auto-unsubscribe)
export class PostListComponent {
  posts$ = this.posts.getPosts();
  constructor(private posts: PostService) {}
}

POST / PUT / DELETE

post/put/patch renvoient des Observables émettant la réponse une fois, puis complétant. Passez le corps en second argument. Le type générique resserre la réponse. L'URL peut être un template literal avec paramètres. Abonnez-vous toujours — les Observables sont froids et ne se déclenchent sinon. Envisagez toPromise() (déprécié) ou firstValueFrom() pour des lectures ponctuelles.

angular
export class PostService {
  private http = inject(HttpClient);

  create(post: Omit<Post, 'id'>) {
    return this.http.post<Post>('/api/posts', post);
  }

  update(id: number, patch: Partial<Post>) {
    return this.http.put<Post>(`/api/posts/${id}`, patch);
  }

  remove(id: number) {
    return this.http.delete<void>(`/api/posts/${id}`);
  }
}

// all return Observables — subscribe or use async pipe
// HTTP methods return a single value then complete

Paramètres de requête et en-têtes

params accepte un objet, HttpParams ou un tableau — Angular les encode dans la query string. headers règle les en-têtes de requête. observe: 'response' renvoie la HttpResponse complète (statut, en-têtes, corps) au lieu du seul corps. observe: 'events' avec reportProgress diffuse les événements de progression pour les uploads/downloads de fichiers.

angular
export class SearchService {
  private http = inject(HttpClient);

  search(term: string, page = 1) {
    return this.http.get<Result[]>('/api/search', {
      params: { q: term, page, sort: 'desc' },
      headers: { 'X-Api-Key': 'secret' },
      observe: 'response',   // get full HttpResponse
      responseType: 'json',
    });
  }

  // observe: 'events' streams upload/download progress
  upload(file: File) {
    return this.http.post('/api/upload', file, {
      reportProgress: true,
      observe: 'events',
    });
  }
}

Intercepteurs

Les intercepteurs fonctionnels (v15+) sont de simples fonctions enchaînées via withInterceptors(). Ils tournent dans l'ordre pour chaque requête, parfaits pour les tokens d'auth, le logging, la logique de reprise ou le cache. clone() crée une requête modifiée (les requêtes sont immuables). La fonction next(req) renvoie le flux de réponse — les opérateurs pipe comme retry, catchError s'appliquent ici.

angular
// functional interceptor (v15+)
export const authInterceptor: HttpInterceptorFn = (req, next) => {
  const token = localStorage.getItem('token');
  const authReq = token
    ? req.clone({ setHeaders: { Authorization: `Bearer ${token}` } })
    : req;
  return next(authReq);
};

// register in app.config.ts
providers: [provideHttpClient(withInterceptors([authInterceptor]))]

// error/logging interceptor
export const loggingInterceptor: HttpInterceptorFn = (req, next) => {
  console.log('Request:', req.url);
  return next(req).pipe(tap({
    error: e => console.error('Failed:', req.url, e),
  }));
};

Gestion des erreurs

Employez les opérateurs RxJS pour la résilience HTTP : retry se réabonne en cas d'erreur, timeout abandonne les requêtes lentes, catchError mappe les erreurs vers des valeurs de repli ou re-lève. Gérez aussi toujours les erreurs côté consommateur — les erreurs d'Observable non attrapées arrêtent le flux. Abonnez-vous avec les callbacks next/error/complete pour gérer tout le cycle de vie.

angular
export class PostService {
  getPost(id: number) {
    return this.http.get<Post>(`/api/posts/${id}`).pipe(
      retry(2),                              // retry on failure
      timeout(5000),                         // abort after 5s
      catchError(err => {
        if (err.status === 404) return of(null);   // graceful fallback
        return throwError(() => new Error('Network error'));
      }),
    );
  }
}

// component-side
this.posts.getPost(1).subscribe({
  next: p => this.post = p,
  error: e => this.error = e.message,
  complete: () => this.loading = false,
});

Réponses typées et withFetch

Les génériques typent le corps de réponse mais ne valident pas à l'exécution — pour la sûreté, employez un validateur d'exécution comme zod. observe: 'response' expose statut, en-têtes et corps. withFetch() (v18) emploie l'API Fetch au lieu de XHR, activant le flux et un meilleur rendu côté serveur. withXsrfConfiguration ajoute la gestion automatique du token CSRF.

angular
// typed generic — response is typed, runtime NOT validated
this.http.get<User[]>('/api/users');

// full HttpResponse observation
this.http.get<User>('/api/users/1', { observe: 'response' })
  .subscribe(res => {
    console.log(res.status);   // 200
    console.log(res.headers.get('X-Total-Count'));
    console.log(res.body);     // User
  });

// opt into fetch() backend (v18+, recommended)
// provideHttpClient(withFetch())

// with XSRF protection enabled
// provideHttpClient(withXsrfConfiguration({ cookieName: 'XSRF-TOKEN' }))
10

Observables et RxJS

Observable de base

Les Observables sont paresseux — le producteur ne tourne qu'à l'abonnement. Ils peuvent émettre zéro ou plusieurs valeurs, puis compléter ou errer. Le callback subscribe reçoit next, error, complete. Désabonnez-vous toujours des abonnements de longue durée (ou employez le pipe async / takeUntilDestroyed). of() émet les valeurs de façon synchrone ; from() aplatit tableaux ou promesses.

angular
import { Observable } from 'rxjs';

const obs = new Observable<number>(subscriber => {
  subscriber.next(1);
  subscriber.next(2);
  setTimeout(() => {
    subscriber.next(3);
    subscriber.complete();
  }, 1000);
});

const sub = obs.subscribe({
  next: v => console.log(v),
  error: e => console.error(e),
  complete: () => console.log('done'),
});

// cleanup
sub.unsubscribe();

// use of(...) for synchronous values
of(1, 2, 3).subscribe(v => console.log(v));
// from(iterable) for arrays/async iterables
from([1, 2, 3]).subscribe(console.log);

Opérateurs courants

Les opérateurs transforment les flux. map/filter fonctionnent comme les méthodes de tableaux. debounceTime attend une période de calme (parfait pour les champs de recherche). distinctUntilChanged saute les valeurs consécutives dupliquées. switchMap annule l'Observable interne précédent quand une nouvelle valeur arrive — parfait pour la recherche à la frappe. Les opérateurs pipe s'enchaînent de gauche à droite.

angular
import { of, from, interval } from 'rxjs';
import { map, filter, switchMap, debounceTime, distinctUntilChanged } from 'rxjs/operators';

of(1, 2, 3, 4).pipe(
  map(x => x * 10),                          // 10, 20, 30, 40
  filter(x => x > 15),                       // 20, 30, 40
).subscribe(console.log);

// search input with debounce
input$.pipe(
  debounceTime(300),
  distinctUntilChanged(),
  switchMap(term => http.get(`/api/search?q=${term}`)),
).subscribe(results => this.results = results);

Combiner des flux

combineLatest émet dès qu'une source émet (après que toutes ont émis au moins une fois) — parfait pour l'état de vue dérivé. forkJoin attend que toutes les sources complètent, renvoyant la dernière valeur de chacune — pour les requêtes HTTP parallèles. merge entrelace les émissions. zip apparie par index. race retient le premier Observable qui émet et ignore le reste.

angular
import { combineLatest, forkJoin, merge, race, zip } from 'rxjs';

// combineLatest: emits when ANY source emits, after all have emitted
combineLatest([user$, settings$]).subscribe(([u, s]) => ...);

// forkJoin: waits for all to complete, emits last values (like Promise.all)
forkJoin({ user: user$, posts: posts$ }).subscribe(r => ...);

// merge: emits values from all sources as they come
merge(clicks$, keys$).subscribe(e => ...);

// zip: pairs emissions by index
zip(range(1, 3), ['a', 'b', 'c']).subscribe(([n, letter]) => ...);

// race: takes the first to emit, ignores the rest
race(primary$, fallback$).subscribe(v => ...);

Subjects (multicast)

Les Subjects sont à la fois Observables et Observers — appelez .next() pour pousser des valeurs. Subject : pas de valeur initiale, les abonnés tardifs ratent les émissions antérieures. BehaviorSubject : exige une valeur initiale, les nouveaux abonnés reçoivent immédiatement la valeur courante (pour l'état). ReplaySubject : met en mémoire tampon les N dernières valeurs pour les nouveaux abonnés (pour rejouer des événements).

angular
import { Subject, BehaviorSubject, ReplaySubject } from 'rxjs';

// Subject: emits to current subscribers only
const click$ = new Subject<MouseEvent>();
click$.subscribe(x => console.log('A:', x));
click$.next({} as MouseEvent);   // A: logs it

// BehaviorSubject: keeps last value, new subs get it immediately
const count$ = new BehaviorSubject(0);
count$.subscribe(v => console.log(v));   // logs 0 immediately
count$.next(1);                          // logs 1 to subscribers

// ReplaySubject: replays last N values to new subscribers
const recent$ = new ReplaySubject<string>(2);
recent$.next('a'); recent$.next('b'); recent$.next('c');
recent$.subscribe(v => console.log(v));  // logs 'b', then 'c'

takeUntil et nettoyage

takeUntil(unsubscribe$) complète automatiquement un abonnement quand le notificateur émet — le pattern standard pour éviter les fuites dans les composants. takeUntilDestroyed() (v16+) emploie le DestroyRef d'Angular pour se désabonner automatiquement sans le passe-partout OnDestroy. Il doit être appelé dans un contexte d'injection (constructeur ou initialisateur de champ) ou accepter un DestroyRef explicitement.

angular
import { Subject, takeUntil, takeUntilDestroyed } from 'rxjs';

export class DemoComponent implements OnDestroy {
  private destroy$ = new Subject<void>();

  ngOnInit() {
    this.svc.stream$.pipe(
      takeUntil(this.destroy$),
    ).subscribe(data => this.data = data);
  }

  ngOnDestroy() { this.destroy$.next(); this.destroy$.complete(); }
}

// v16+: takeUntilDestroyed (uses DestroyRef, no boilerplate)
export class DemoComponent {
  data: any;
  constructor() {
    inject(SomeService).stream$.pipe(
      takeUntilDestroyed(),
    ).subscribe(d => this.data = d);
  }
}

switchMap vs mergeMap vs concatMap

Ces opérateurs d'aplatissement diffèrent dans le traitement des Observables internes qui se chevauchent. switchMap annule (recherche à la frappe). mergeMap parallélise (charger beaucoup). concatMap met en file (préserve l'ordre). exhaustMap jette (prévient les doubles soumissions). Choisir le mauvais cause des conditions de course — accordez l'opérateur à la sémantique d'annulation du cas d'usage.

angular
import { from, interval } from 'rxjs';
import { switchMap, mergeMap, concatMap, exhaustMap } from 'rxjs/operators';

// switchMap: cancels the previous inner stream on new value
input$.pipe(switchMap(term => search(term)));
// Best for: typeahead search (discard stale results)

// mergeMap: runs all inner streams in parallel
ids$.pipe(mergeMap(id => fetchDetail(id)));
// Best for: parallel requests, order doesn't matter

// concatMap: queues inner streams, runs one at a time
queue$.pipe(concatMap(task => runTask(task)));
// Best for: ordered sequential operations

// exhaustMap: ignores new values while inner stream is active
save$.pipe(exhaustMap(() => saveForm()));
// Best for: prevent double-submit (ignore clicks while saving)
11

Hooks de cycle de vie

Aperçu de l'ordre des hooks

Les hooks se déclenchent dans un ordre strict. ngOnChanges se déclenche aux changements d'@Input (et au départ). ngOnInit une fois après le premier ngOnChanges. ngDoCheck à chaque cycle de détection de changements. Les hooks After* signalent que contenu/vue sont prêts pour les requêtes DOM. ngOnDestroy est le point de nettoyage — désabonnements, libération de ressources, annulation de minuteurs.

angular
export class LifecycleComponent implements
    OnChanges, OnInit, DoCheck, AfterContentInit,
    AfterContentChecked, AfterViewInit, AfterViewChecked, OnDestroy {

  ngOnChanges()    { console.log('1. input changes'); }
  ngOnInit()       { console.log('2. component init (once)'); }
  ngDoCheck()      { console.log('3. custom change detection'); }
  ngAfterContentInit()      { console.log('4. projected content ready'); }
  ngAfterContentChecked()   { console.log('5. projected content checked'); }
  ngAfterViewInit()         { console.log('6. view (template) ready'); }
  ngAfterViewChecked()      { console.log('7. view checked'); }
  ngOnDestroy()    { console.log('8. cleanup before destroy'); }
}

ngOnInit et ngOnDestroy

ngOnInit tourne une fois après le réglage des inputs — le bon endroit pour l'init coûteuse (fetch, abonnements) puisque le constructeur devrait rester bon marché. ngOnDestroy est le seul hook appelé à la destruction du composant — ne sautez jamais le nettoyage ici sinon vous fuirez abonnements, minuteurs et écouteurs. Le constructeur ne sert qu'à la DI ; employez ngOnInit pour la logique.

angular
export class ChartComponent implements OnInit, OnDestroy {
  private timer?: ReturnType<typeof setInterval>;

  ngOnInit() {
    // good for: data fetching, initialization, subscriptions
    this.timer = setInterval(() => this.refresh(), 5000);
    this.loadInitialData();
  }

  ngOnDestroy() {
    // cleanup: clear timers, unsubscribe, release resources
    if (this.timer) clearInterval(this.timer);
    // also: this.sub.unsubscribe();
  }

  private refresh() { /* ... */ }
  private loadInitialData() { /* ... */ }
}

ngOnChanges (SimpleChange)

ngOnChanges se déclenche à chaque changement de référence d'@Input, avec une map SimpleChanges : chaque entrée a previousValue, currentValue, firstChange et isFirstChange(). Il ne se déclenche PAS quand on mute les propriétés d'un objet — seulement au changement de référence. Pour les changements profonds, employez ngOnChanges avec un setter ou ngDoCheck avec IterableDiffers.

angular
export class PaginationComponent implements OnChanges {
  @Input() page = 1;
  @Input() total = 0;

  ngOnChanges(changes: SimpleChanges) {
    if (changes['page'] && !changes['page'].firstChange) {
      // react only when page actually changed (not on init)
      console.log('page:', changes['page'].previousValue, '->', changes['page'].currentValue);
      this.fetchPage(this.page);
    }
  }

  private fetchPage(p: number) { /* ... */ }
}

ngAfterViewInit et ViewChild

Les requêtes ViewChild/ContentChild se résolvent APRÈS leurs hooks d'init respectifs. ngAfterViewInit pour les éléments du template propre du composant ; ngAfterContentInit pour le contenu projeté via <ng-content>. Y accéder dans ngOnInit renvoie undefined. L'assertion non-null ! dit au compilateur que c'est réglé après l'init — mais seulement sûr dans les hooks After*.

angular
export class CanvasComponent implements AfterViewInit {
  @ViewChild('canvas') canvasRef!: ElementRef<HTMLCanvasElement>;

  // ❌ canvasRef is undefined in ngOnInit
  ngOnInit() { /* this.canvasRef is undefined here */ }

  // ✅ available after view init
  ngAfterViewInit() {
    const canvas = this.canvasRef.nativeElement;
    const ctx = canvas.getContext('2d');
    ctx?.fillText('Hello', 10, 50);
  }
}

// template: <canvas #canvas></canvas>

ngDoCheck (détection personnalisée)

ngDoCheck tourne à chaque cycle de détection de changements — gardez-le léger. Employez IterableDiffers/KeyValueDiffers pour détecter les mutations de tableaux/objets que ngOnChanges rate (puisque les références ne changent pas). C'est l'échappatoire pour suivre les mutations internes. Évitez la logique coûteuse ici ; il tourne souvent et peut causer des problèmes de performance.

angular
export class ListComponent implements DoCheck {
  @Input() items: Item[] = [];
  private differ: IterableDiffer<Item>;

  constructor(differs: IterableDiffers) {
    this.differ = differs.find(items).create<Item>((i) => i.id);
  }

  ngDoCheck() {
    const changes = this.differ.diff(this.items);
    if (changes) {
      changes.forEachAddedItem(r => console.log('Added:', r.item));
      changes.forEachRemovedItem(r => console.log('Removed:', r.item));
    }
  }
}

Hooks de contenu vs de vue

Les hooks de contenu (AfterContentInit/Checked) se déclenchent pour le contenu projeté via <ng-content>. Les hooks de vue (AfterViewInit/Checked) pour le template propre du composant. Les hooks de contenu se déclenchent AVANT ceux de vue car le contenu s'initialise avant l'achèvement de la vue. @ContentChild interroge les éléments projetés ; @ViewChild ceux du template propre.

angular
export class CardComponent implements
    AfterContentInit, AfterViewInit, AfterContentChecked, AfterViewChecked {

  @ContentChild('header') headerTpl?: TemplateRef<unknown>;
  @ViewChild('body') bodyEl?: ElementRef<HTMLElement>;

  // projected content (<ng-content>) is ready
  ngAfterContentInit() {
    console.log('content ready:', this.headerTpl);
  }

  // own template view is ready
  ngAfterViewInit() {
    console.log('view ready:', this.bodyEl?.nativeElement);
  }

  // ContentChecked/ViewChecked run every CD cycle after init — beware perf
}
12

Projection de contenu

ng-content de base

<ng-content> est un espace réservé où se projette le contenu fourni par le parent. Pensez au <slot> d'Angular. Sans select, tout le contenu projeté arrive ici. Le contenu projeté se compile dans le contexte du parent — les liaisons comme {{ }} se résolvent contre le composant parent, pas CardComponent.

angular
// card.component.ts
@Component({
  selector: 'app-card',
  template: `
    <div class="card">
      <ng-content></ng-content>
    </div>
  `,
  styles: ['.card { border: 1px solid #ccc; padding: 16px; }'],
})
export class CardComponent {}

<!-- usage: anything inside projects into <ng-content> -->
<app-card>
  <h3>Title</h3>
  <p>Body content here.</p>
</app-card>

Projection multi-emplacements

L'attribut select sur ng-content vise un contenu projeté précis : par élément ('header'), attribut ('[header]'), classe ('.active') ou combinaisons ('div.foo[bar]'). Le contenu non apparié tombe dans le ng-content sans select. Le contenu projeté garde les styles et le contexte du parent — seule sa position dans le DOM change.

angular
@Component({
  selector: 'app-layout',
  template: `
    <header><ng-content select="[header]"></ng-content></header>
    <main><ng-content></ng-content></main>
    <footer><ng-content select="footer"></ng-content></footer>
  `,
})
export class LayoutComponent {}

<!-- usage: select matches attributes, elements, classes -->
<app-layout>
  <nav header>Top nav</nav>
  <p>Main body</p>
  <footer>Bottom</footer>
</app-layout>

Projection conditionnelle (ng-template)

Pour une projection conditionnelle ou répétée, ng-template avec ngTemplateOutlet donne le contrôle total. ContentChildren interroge les directives projetées. ngTemplateOutlet rend un TemplateRef à l'emplacement choisi — utile pour onglets, accordéons ou emplacements conditionnels. Ce pattern découple la déclaration du contenu de son endroit/moment de rendu.

angular
@Component({
  selector: 'app-tabs',
  template: `
    <div class="tabs">
      @for (t of tabs; track t) {
        <button (click)="active = t">{{ t.title }}</button>
      }
    </div>
    @for (t of tabs; track t) {
      @if (t === active) {
        <ng-container [ngTemplateOutlet]="t.template" />
      }
    }
  `,
})
export class TabsComponent {
  @ContentChildren(TabDirective) tabs!: QueryList<TabDirective>;
  active: any;
}

ContentChild et ContentChildren

@ContentChild / @ContentChildren interroge le contenu projeté (vs ViewChild pour le template propre). ContentChildren renvoie une QueryList qui se met à jour quand le contenu change. Résolution dans ngAfterContentInit. L'option { descendants: true } (défaut) parcourt tout le contenu projeté. Employez { read: ... } pour interroger un type précis (ElementRef, TemplateRef, etc.).

angular
@Directive({ selector: 'tab' })
export class TabDirective {
  @Input() title = '';
  @Input() active = false;
  @ContentChild(TemplateRef) template!: TemplateRef<unknown>;
}

@Component({
  selector: 'app-tabset',
  template: `
    @for (tab of tabs; track tab) {
      <button (click)="select(tab)">{{ tab.title }}</button>
    }
    <ng-container *ngTemplateOutlet="activeTab?.template" />
  `,
})
export class TabsetComponent implements AfterContentInit {
  @ContentChildren(TabDirective) tabs!: QueryList<TabDirective>;
  activeTab?: TabDirective;

  ngAfterContentInit() {
    this.activeTab = this.tabs.find(t => t.active) ?? this.tabs.first;
  }
}

ngTemplateOutlet avec contexte

ngTemplateOutlet rend un TemplateRef avec un contexte optionnel. let-x se lie à context.$implicit (la valeur par défaut) ; let-y='clé' se lie à context.clé. C'est ainsi que *ngFor et ngTemplateOutlet passent les variables de boucle. Employez ce pattern pour des templates de liste/grille/item réutilisables que les parents personnalisent pendant que le composant contrôle la logique d'itération.

angular
@Component({
  selector: 'app-list',
  template: `
    @for (item of items; track item.id) {
      <ng-container *ngTemplateOutlet="itemTpl; context: { $implicit: item, i: $index }" />
    }
    <ng-template #itemTpl let-item let-i="i">
      <li>{{ i }}: {{ item.name }}</li>
    </ng-template>
  `,
})
export class ListComponent {
  items = [{ id: 1, name: 'A' }, { id: 2, name: 'B' }];
}

Patterns de select de ng-content

select accepte des sélecteurs façon CSS : classes (.x), attributs ([x]), éléments (header) ou listes séparées par virgules ('a, b'). Le contenu matchant aucun sélecteur tombe dans le ng-content sans select. Sans repli existant, le contenu non apparié est jeté. Les sélecteurs matchent les attributs propres des éléments projetés, pas leur structure interne.

angular
@Component({
  selector: 'app-modal',
  template: `
    <div class="modal">
      <ng-content select=".modal-header"></ng-content>
      <ng-content select="[body]"></ng-content>
      <ng-content select="app-modal-footer, footer"></ng-content>
      <!-- fallback for unmatched content -->
      <ng-content></ng-content>
    </div>
  `,
})

<!-- matches by class, attribute, element, or selector list -->
<app-modal>
  <div class="modal-header">Title</div>
  <section body>Body text</section>
  <app-modal-footer>OK</app-modal-footer>
  <p>This falls into the unselect'd slot.</p>
</app-modal>
13

Guards de route

CanActivate (fonctionnel)

Les guards fonctionnels (v14.2+) renvoient true/false/UrlTree ou un Observable/Promise de ceux-ci. Renvoyer un UrlTree redirige vers cette route. inject() fonctionne car les guards tournent dans un contexte d'injection. CanActivate empêche la navigation vers une route. Enregistrez les guards par route dans le tableau canActivate. Ils tournent à chaque navigation vers cette route.

angular
import { inject } from '@angular/core';
import { CanActivateFn, Router } from '@angular/router';

export const authGuard: CanActivateFn = (route, state) => {
  const auth = inject(AuthService);
  const router = inject(Router);

  if (auth.isLoggedIn) return true;

  // redirect to login, preserving the attempted URL
  return router.createUrlTree(['/login'], {
    queryParams: { returnUrl: state.url },
  });
};

// register in routes
{ path: 'dashboard', component: DashboardComponent, canActivate: [authGuard] }

CanActivateChild

CanActivateChild tourne avant chaque route enfant sous le parent — plus propre que de répéter canActivate sur chaque enfant. Employez-le pour la protection partagée d'une zone de fonctionnalités. Renvoie les mêmes types de valeurs que CanActivate. Pour protéger aussi le parent lui-même, ajoutez aussi canActivate sur la route parente.

angular
export const adminGuard: CanActivateChildFn = (route, state) => {
  const auth = inject(AuthService);

  if (!auth.isAdmin) {
    return inject(Router).parseUrl('/forbidden');
  }
  return true;
};

// applies to all children of this route
{
  path: 'admin',
  canActivateChild: [adminGuard],
  children: [
    { path: 'users', component: AdminUsersComponent },
    { path: 'settings', component: AdminSettingsComponent },
  ],
}

CanDeactivate (changements non enregistrés)

CanDeactivate tourne avant de quitter une route — parfait pour avertir de changements de formulaire non enregistrés. Le guard reçoit l'instance du composant, il appelle donc une méthode dessus. Renvoyez false pour annuler la navigation, true pour continuer. Pour l'asynchrone (confirmation modale), renvoyez un Observable ou une Promise. Le composant doit implémenter le contrat que le guard attend.

angular
import { CanDeactivateFn } from '@angular/router';
import { inject } from '@angular/core';

export interface CanComponentDeactivate {
  canDeactivate: () => boolean | Observable<boolean>;
}

export const unsavedGuard: CanDeactivateFn<CanComponentDeactivate> = (component) => {
  return component?.canDeactivate() ?? true;
};

// component
export class EditComponent implements CanComponentDeactivate {
  canDeactivate() {
    if (this.form.dirty) return confirm('Discard changes?');
    return true;
  }
}

// route: { path: 'edit/:id', canDeactivate: [unsavedGuard] }

CanMatch (chargement conditionnel)

CanMatch (v14.1+) tourne avant même le téléchargement du chunk d'une route paresseuse — plus efficace que CanActivate pour le filtrage des fonctionnalités payantes. S'il renvoie false, la route est entièrement sautée (les autres routes correspondantes ont leur chance). CanActivate chargerait d'abord le chunk puis refuserait. Employez CanMatch pour empêcher de télécharger du code inaccessible à l'utilisateur.

angular
import { CanMatchFn } from '@angular/router';

export const paidFeatureGuard: CanMatchFn = (route, segments) => {
  const auth = inject(AuthService);
  // runs BEFORE the lazy chunk is even loaded
  if (auth.hasProPlan) return true;

  return inject(Router).createUrlTree(['/upgrade']);
};

// route configuration
{
  path: 'premium',
  canMatch: [paidFeatureGuard],
  loadComponent: () => import('./premium/premium.component'),
}

Resolve (pré-charger les données)

Resolve tourne avant l'activation de la route, retardant la navigation jusqu'à l'arrivée des données. Les données résolues atterrissent dans route.snapshot.data. Utile pour garantir que les composants ont les données au rendu (pas de flash d'état vide). Gérez les erreurs dans le resolver — renvoyer EMPTY annule la navigation. Pour des chargements non bloquants, fetchez dans ngOnInit.

angular
import { ResolveFn } from '@angular/router';
import { inject } from '@angular/core';

export const userResolver: ResolveFn<User> = (route) => {
  const id = route.paramMap.get('id')!;
  return inject(UserService).getUser(+id).pipe(
    catchError(() => {
      inject(Router).navigate(['/users']);
      return EMPTY;
    }),
  );
};

// route
{ path: 'users/:id', resolve: { user: userResolver }, component: UserComponent }

// component reads pre-fetched data
export class UserComponent {
  user = this.route.snapshot.data['user'] as User;
  constructor(private route: ActivatedRoute) {}
}

Composition et ordre des guards

Plusieurs guards tournent dans l'ordre du tableau ; le premier qui échoue annule la navigation. canMatch tourne avant le chargement des chunks paresseux ; canActivate après. canDeactivate tourne au départ. Tous les guards peuvent être synchrones (booléen) ou asynchrones (Observable/Promise). Gardez-les rapides — ils bloquent l'UI. Les lourdes vérifications serveur devraient être debouncées ou mises en cache.

angular
// multiple guards run in declaration order, all must pass
{
  path: 'admin',
  canActivate: [authGuard, roleGuard],
  canMatch: [paidFeatureGuard],
  canDeactivate: [unsavedGuard],
  loadChildren: () => import('./admin/admin.routes'),
}

// guard returning Observable (async check)
export const roleGuard: CanActivateFn = () => {
  return inject(AuthService).hasRole('admin').pipe(
    map(ok => ok || inject(Router).parseUrl('/forbidden')),
  );
};

// ordering: canMatch → resolve → canActivate → canActivateChild
14

Resolvers

Resolver de base (ResolveFn)

ResolveFn est l'API de resolver fonctionnel. Il tourne avant l'achèvement de la navigation, et la valeur renvoyée se place dans route.data sous la clé assignée. Le composant peut la lire de façon synchrone dans snapshot.data — pas d'état de chargement nécessaire. Abonnez-vous à route.data pour des mises à jour réactives entre routes du même composant.

angular
import { ResolveFn } from '@angular/router';
import { inject } from '@angular/core';

export const postResolver: ResolveFn<Post> = (route, state) => {
  const id = Number(route.paramMap.get('id'));
  return inject(PostService).getPost(id);
};

// route
{
  path: 'posts/:id',
  resolve: { post: postResolver },
  component: PostDetailComponent,
}

// reading the resolved data
export class PostDetailComponent {
  post = this.route.snapshot.data['post'] as Post;
  constructor(private route: ActivatedRoute) {}

  // reactive: re-fetch when :id changes (same component reused)
  ngOnInit() {
    this.route.data.subscribe(d => this.post = d['post']);
  }
}

Plusieurs resolvers

Plusieurs resolvers tournent en parallèle — tous doivent compléter avant l'activation de la route. Chaque clé de resolve devient une clé de route.data. Si l'un échoue, la navigation est annulée. Pour des données indépendantes, c'est efficace. Si l'un dépend d'un autre, imbriquez-les ou enchaînez dans un seul resolver. Pesez resolver vs fetch dans ngOnInit.

angular
{
  path: 'dashboard',
  component: DashboardComponent,
  resolve: {
    user: userResolver,
    stats: statsResolver,
    notifications: notifResolver,
  },
}

// component
export class DashboardComponent {
  constructor(private route: ActivatedRoute) {}
  ngOnInit() {
    const { user, stats, notifications } = this.route.snapshot.data;
    // all three resolved before component loads
  }
}

Gestion des erreurs de resolver

Gérez explicitement les erreurs de resolver — les erreurs non attrapées annulent la navigation en silence. EMPTY complète le flux sans émettre, annulant la navigation. Renvoyer null laisse le composant gérer gracieusement les données manquantes. Pour les 404, redirigez vers une route not-found. Journalisez ou exposez toujours les erreurs ; les échecs silencieux sont durs à déboguer pour les utilisateurs.

angular
export const userResolver: ResolveFn<User | null> = (route) => {
  const id = route.paramMap.get('id')!;
  const router = inject(Router);
  const service = inject(UserService);

  return service.getUser(+id).pipe(
    catchError(err => {
      if (err.status === 404) {
        // redirect to a 'not found' page, cancel navigation
        router.navigate(['/404']);
        return EMPTY;
      }
      // re-throw other errors
      return throwError(() => err);
    }),
  );
};

Resolver vs fetch dans ngOnInit

Les resolvers bloquent la navigation jusqu'à l'arrivée des données — UX propre mais paraît plus lent. Le fetch dans ngOnInit est non bloquant mais exige des états de chargement dans le composant. Les conseils modernes d'Angular penchent vers le non-bloquant : fetcher dans le composant avec un squelette de chargement pour une meilleure performance perçue. N'employez les resolvers que si le composant ne peut vraiment pas se rendre sans les données.

angular
// Approach A: Resolver (blocks navigation until data arrives)
// ✅ Component renders with data — no flicker
// ❌ Slower navigation feel, blocks route transition
{
  path: 'user/:id',
  resolve: { user: userResolver },
  component: UserComponent,
}

// Approach B: Fetch in ngOnInit (non-blocking)
// ✅ Snappy navigation, show loading skeleton
// ❌ Component must handle null/loading state
export class UserComponent implements OnInit {
  user?: User;
  loading = true;
  ngOnInit() {
    this.route.params.subscribe(p => {
      this.loading = true;
      this.svc.getUser(+p['id']).subscribe(u => {
        this.user = u;
        this.loading = false;
      });
    });
  }
}

Resolver avec paramètres de requête et signaux

Les resolvers peuvent lire à la fois paramMap et queryParamMap de la route. Quand le même composant traite des paramètres différents, abonnez-vous à route.data de façon réactive au lieu du snapshot. Avec les signaux, mettez à jour un signal depuis l'abonnement aux données. Combinez resolvers et signaux pour un flux de données propre et réactif. Évitez les resolvers lourds — ils bloquent la navigation.

angular
// read query params inside a resolver
export const searchResolver: ResolveFn<SearchResult[]> = (route) => {
  const q = route.queryParamMap.get('q') ?? '';
  const page = Number(route.queryParamMap.get('page') ?? 1);
  return inject(SearchService).search(q, page);
};

// resolver feeding a signal-based component
export class SearchComponent {
  private route = inject(ActivatedRoute);
  results = signal<SearchResult[]>([]);

  constructor() {
    this.route.data.subscribe(d => this.results.set(d['results']));
  }
}
15

Animations

Configuration et animation de base

provideAnimations() enregistre le module d'animations. trigger() définit une animation nommée ; transition() déclare le changement entre états. :enter et :leave sont des pseudo-états intégrés pour les éléments ajoutés/retirés via *ngIf ou @if. Appliquez via @triggerName dans le template. Pour le flux de contrôle v17+, les animations fonctionnent toujours avec @if/@for.

angular
// app.config.ts
import { provideAnimations } from '@angular/platform-browser/animations';
export const appConfig: ApplicationConfig = {
  providers: [provideAnimations()],
};

// component
@Component({
  selector: 'app-fade',
  animations: [
    trigger('fadeIn', [
      transition(':enter', [
        style({ opacity: 0 }),
        animate('300ms ease-in', style({ opacity: 1 })),
      ]),
      transition(':leave', [
        animate('300ms ease-out', style({ opacity: 0 })),
      ]),
    ]),
  ],
  template: `<div *ngIf="show" @fadeIn>Hello</div>`,
})

États et transitions

state() définit des styles nommés au repos. transition('a => b') anime de l'état a vers b ; '<=>' est bidirectionnel. Liez le trigger à une expression renvoyant le nom d'état. Les styles d'état s'appliquent immédiatement (pas d'animation) ; les transitions animent entre eux. Employez 'void' pour les éléments pas encore dans le DOM, et '*' comme joker.

angular
@Component({
  selector: 'app-toggle',
  animations: [
    trigger('openClose', [
      state('open', style({ height: '*', opacity: 1 })),
      state('closed', style({ height: '0', opacity: 0 })),
      transition('open => closed', animate('200ms ease-out')),
      transition('closed => open', animate('300ms ease-in')),
      // bidirectional shortcut: 'open <=> closed'
    ]),
  ],
  template: `
    <button (click)="isOpen = !isOpen">Toggle</button>
    <div [@openClose]="isOpen ? 'open' : 'closed'">Panel</div>
  `,
})
export class ToggleComponent { isOpen = false; }

Keyframes et animations parallèles

keyframes() définit des étapes intermédiaires avec offset (0 à 1) pour un contrôle fin — comme les @keyframes CSS. group() exécute les animations en parallèle ; sequence() l'une après l'autre. Employez-les pour composer des effets d'entrée/sortie complexes. Gardez des animations courtes (200-400ms) et respectez prefers-reduced-motion pour l'accessibilité.

angular
trigger('wiggle', [
  transition('* => *', [
    animate('600ms ease-in-out', keyframes([
      style({ transform: 'translateX(0)', offset: 0 }),
      style({ transform: 'translateX(-10px)', offset: 0.25 }),
      style({ transform: 'translateX(10px)', offset: 0.75 }),
      style({ transform: 'translateX(0)', offset: 1 }),
    ])),
  ]),
]),

// parallel/group animations
transition(':enter', [
  group([
    animate('300ms', style({ opacity: 1 })),
    animate('300ms', style({ transform: 'translateY(0)' })),
  ]),
]),

Liste animée (@for)

Appliquez les animations :enter/:leave aux items de @for — elles se déclenchent quand des items sont ajoutés ou retirés. track garantit qu'Angular identifie correctement les items entre les changements, les animations se déclenchent donc sur de vrais ajouts/retraits (pas un réordonnancement). Les animations de listes peuvent être saccadées sans track correct. Pour les animations de réordonnancement, employez query() et animateChild().

angular
@Component({
  selector: 'app-list',
  animations: [
    trigger('itemAnim', [
      transition(':enter', [
        style({ height: 0, opacity: 0 }),
        animate('200ms', style({ height: '*', opacity: 1 })),
      ]),
      transition(':leave', [
        animate('200ms', style({ height: 0, opacity: 0 })),
      ]),
    ]),
  ],
  template: `
    @for (item of items; track item.id) {
      <div @itemAnim>{{ item.name }}</div>
    }
  `,
})
export class AnimListComponent { items = [...]; }

Animations de routeur

Lie le trigger d'animation à l'état d'activation du router-outlet. query(':enter'/:leave) vise les composants routés entrants/sortants. { optional: true } évite les erreurs quand un côté n'existe pas (le chargement initial n'a pas de :leave). position: absolute empile les composants ancien et nouveau pendant la transition. Les animations de route donnent des transitions façon app entre les vues.

angular
@Component({
  selector: 'app-root',
  animations: [
    trigger('routeAnim', [
      transition('* => *', [
        query(':enter', [
          style({ opacity: 0, position: 'absolute', width: '100%' }),
          animate('300ms', style({ opacity: 1 })),
        ], { optional: true }),
        query(':leave', [
          animate('300ms', style({ opacity: 0 })),
        ], { optional: true }),
      ]),
    ]),
  ],
  template: `
    <div [@routeAnim]="o.isActivated ? o.activatedRoute : ''">
      <router-outlet #o="outlet"></router-outlet>
    </div>
  `,
})

Mouvement réduit et animations CSS

Respectez toujours prefers-reduced-motion pour l'accessibilité — certains utilisateurs ont le mal des transports. Les animations Angular ajoutent ~50 Ko au bundle ; pour de simples fondus, des animations CSS pures peuvent suffire. Employez les animations Angular pour des transitions avec état (machines d'état), une coordination parent-enfant ou des animations de route. Le CSS est plus léger pour les effets de survol/fondu.

angular
// respect prefers-reduced-motion
@Component({
  selector: 'app-safe-anim',
  animations: [
    trigger('fade', [
      transition(':enter', [
        style({ opacity: 0 }),
        animate('300ms', style({ opacity: 1 })),
      ]),
    ]),
  ],
  // or just use CSS — Angular animations add bundle weight
  template: `<div class="fade-in" @fade>Content</div>`,
  styles: [`
    @media (prefers-reduced-motion: reduce) {
      .fade-in { animation: none !important; transition: none !important; }
    }
  `],
})
16

Tests

Configuration de test de composant

TestBed configure le module de test. Pour les composants standalone, importez-les directement (pas de déclarations TestBed.configureTestingModule nécessaires). createComponent renvoie une ComponentFixture : .componentInstance pour la classe, .nativeElement pour le DOM, .detectChanges() pour déclencher la détection de changements. beforeEach avec async/await gère compileComponents.

angular
import { ComponentFixture, TestBed } from '@angular/core/testing';
import { MyComponent } from './my.component';

describe('MyComponent', () => {
  let fixture: ComponentFixture<MyComponent>;
  let component: MyComponent;

  beforeEach(async () => {
    await TestBed.configureTestingModule({
      imports: [MyComponent],   // standalone components are imported
    }).compileComponents();

    fixture = TestBed.createComponent(MyComponent);
    component = fixture.componentInstance;
    fixture.detectChanges();   // runs initial change detection
  });

  it('should create', () => {
    expect(component).toBeTruthy();
  });
});

Tester avec des services mock

Fournissez des implémentations mock des services pour isoler le composant testé. jasmine.createSpy() permet de contrôler les valeurs de retour et d'affirmer les appels. Employez useValue pour les mocks objets, useClass pour les fakes à base de classes. Surchargez HttpClient avec HttpTestingController pour les tests HTTP. Le mocking garde les tests rapides et déterministes — pas de vrais appels réseau.

angular
describe('UserComponent', () => {
  let mockUserService = {
    getUsers: jasmine.createSpy().and.returnValue(of([...])),
    addUser: jasmine.createSpy().and.returnValue(of({})),
  };

  beforeEach(async () => {
    await TestBed.configureTestingModule({
      imports: [UserComponent],
      providers: [
        { provide: UserService, useValue: mockUserService },
      ],
    }).compileComponents();
  });

  it('loads users on init', () => {
    const fixture = TestBed.createComponent(UserComponent);
    fixture.detectChanges();
    expect(mockUserService.getUsers).toHaveBeenCalled();
    expect(fixture.componentInstance.users.length).toBe(2);
  });
});

Tests HTTP

HttpTestingController intercepte les appels HttpClient dans les tests — pas de vrai réseau. expectOne affirme qu'une requête a été faite et la renvoie ; flush() simule la réponse du serveur. verify() garantit qu'il ne reste aucune requête non appariée. Testez les chemins de succès et d'erreur : flush avec un code de statut (ex. { status: 500, statusText: 'Server Error' }) pour simuler des erreurs.

angular
import { HttpTestingController, provideHttpClientTesting } from '@angular/common/http/testing';
import { provideHttpClient } from '@angular/common/http';

describe('PostService', () => {
  let service: PostService;
  let httpMock: HttpTestingController;

  beforeEach(() => {
    TestBed.configureTestingModule({
      providers: [
        PostService,
        provideHttpClient(),
        provideHttpClientTesting(),
      ],
    });
    service = TestBed.inject(PostService);
    httpMock = TestBed.inject(HttpTestingController);
  });

  it('fetches posts', () => {
    service.getPosts().subscribe(posts => expect(posts.length).toBe(2));

    const req = httpMock.expectOne('/api/posts');
    expect(req.request.method).toBe('GET');
    req.flush([{ id: 1 }, { id: 2 }]);   // simulate response
    httpMock.verify();                    // no outstanding requests
  });
});

Tester le template et les interactions

fixture.nativeElement donne un accès DOM brut pour les assertions. detectChanges() synchronise les liaisons du template après réglage des propriétés. spyOn permet d'affirmer les appels de méthodes. Pour les requêtes internes au composant, debugElement.query(By.css()) est type-safe. Déclenchez les événements via les méthodes DOM natives (click()) ou DebugElement.triggerEventHandler pour les événements personnalisés.

angular
it('renders the title', () => {
  const fixture = TestBed.createComponent(MyComponent);
  fixture.componentInstance.title = 'Hello';
  fixture.detectChanges();
  const el: HTMLElement = fixture.nativeElement;
  expect(el.querySelector('h1')?.textContent).toContain('Hello');
});

it('calls save on button click', () => {
  const fixture = TestBed.createComponent(MyComponent);
  const spy = spyOn(fixture.componentInstance, 'save');
  const button = fixture.nativeElement.querySelector('button');
  button.click();
  expect(spy).toHaveBeenCalled();
});

// By.css for debug element queries (faster than nativeElement)
const debugEl = fixture.debugElement.query(By.css('.submit'));

Tester les signaux

Les signaux sont des fonctions — appelez-les (avec parenthèses) pour lire les valeurs dans les tests. set() met à jour directement les signaux inscriptibles, évitant la manipulation indirecte. detectChanges() synchronise les templates pilotés par signaux. Pour computed/effect, detectChanges ou TestBed.flushEffects() garantit que les effets dépendants tournent. Les signaux rendent les tests plus synchrones et prévisibles.

angular
describe('CounterComponent', () => {
  it('increments count', () => {
    const fixture = TestBed.createComponent(CounterComponent);
    const comp = fixture.componentInstance;

    expect(comp.count()).toBe(0);
    comp.increment();
    expect(comp.count()).toBe(1);

    // force signal effects to run in tests
    fixture.detectChanges();
  });

  it('renders count in template', () => {
    const fixture = TestBed.createComponent(CounterComponent);
    fixture.componentInstance.count.set(5);
    fixture.detectChanges();   // syncs signal to template
    expect(fixture.nativeElement.textContent).toContain('5');
  });
});

E2E avec Cypress / Playwright

Les tests E2E exercent toute l'app dans un vrai navigateur. Employez les attributs data-cy comme sélecteurs — stables et non couplés aux classes CSS. Cypress tourne dans le navigateur ; Playwright sur plusieurs navigateurs. Employez ng e2e ou configurez Cypress/Playwright manuellement. Les tests E2E attrapent les problèmes d'intégration que les tests unitaires ratent mais sont plus lents — gardez la suite concentrée.

angular
// cypress test (cypress/e2e/login.cy.ts)
describe('Login flow', () => {
  beforeEach(() => cy.visit('/login'));

  it('logs in with valid credentials', () => {
    cy.get('[data-cy=email]').type('[email protected]');
    cy.get('[data-cy=password]').type('secret123');
    cy.get('[data-cy=submit]').click();

    cy.url().should('include', '/dashboard');
    cy.contains('Welcome, User');
  });
});

// run with: npx cypress open  (interactive)
//           npx cypress run   (headless CI)
17

PWA

Ajouter le support PWA

ng add @angular/pwa échafaude tout : enregistrement du service worker, manifest web et icônes. Le service worker ne tourne que dans les builds de production (ng build --configuration production) — désactivé en dev pour éviter les surprises de cache. registrationStrategy contrôle quand le SW s'enregistre ; registerWhenStable attend que l'app se stabilise.

angular
# add @angular/service-worker
ng add @angular/pwa --project my-app

# this generates:
# - ngsw-config.json (service worker config)
# - manifest.webmanifest
# - icons in src/assets/icons/
# - registers service worker in app.config.ts

# app.config.ts (auto-updated)
export const appConfig: ApplicationConfig = {
  providers: [
    provideRouter(routes),
    provideServiceWorker('ngsw-worker.js', {
      enabled: environment.production,
      registrationStrategy: 'registerWhenStable:30000',
    }),
  ],
};

Config du service worker (ngsw-config.json)

assetGroups met en cache la coquille de l'app (prefetch) et les ressources statiques (lazy). dataGroups met en cache les réponses d'API avec des stratégies freshness/performance et des TTL. prefetch télécharge avec empressement ; lazy à la demande. freshness essaie le réseau d'abord, replie vers le cache (bien pour des données fraîches) ; performance emploie le cache d'abord (bien pour des données quasi statiques).

angular
{
  "$schema": "./node_modules/@angular/service-worker/config/schema.json",
  "index": "/index.html",
  "assetGroups": [
    {
      "name": "app",
      "installMode": "prefetch",
      "updateMode": "prefetch",
      "resources": {
        "files": ["/favicon.ico", "/index.html", "/manifest.webmanifest", "/*.css", "/*.js"]
      }
    },
    {
      "name": "assets",
      "installMode": "lazy",
      "updateMode": "prefetch",
      "resources": { "files": ["/assets/**", "/*.(svg|png|jpg|jpeg|webp|woff2)"] }
    }
  ],
  "dataGroups": [
    {
      "name": "api",
      "urls": ["https://api.example.com/**"],
      "cacheConfig": {
        "maxSize": 100, "maxAge": "1d", "timeout": "10s", "strategy": "freshness"
      }
    }
  ]
}

Gérer les mises à jour

SwUpdate notifie quand une nouvelle version est disponible. VERSION_READY signifie qu'un nouveau bundle est téléchargé et prêt à s'activer. activateUpdate() bascule vers la nouvelle version ; reload pour la charger. Pour les mises à jour critiques, forcez l'activation immédiatement. Pour les non critiques, invitez l'utilisateur. Abonnez-vous à versionUpdates pour gérer VERSION_DETECTED, VERSION_READY et NO_NEW_VERSION_DETECTED.

angular
import { SwUpdate } from '@angular/service-worker';
import { inject } from '@angular/core';

export class UpdatePromptComponent {
  private updates = inject(SwUpdate);
  updateAvailable = false;

  constructor() {
    this.updates.versionUpdates.subscribe(evt => {
      if (evt.type === 'VERSION_READY') {
        this.updateAvailable = true;
      }
    });
  }

  applyUpdate() {
    this.updates.activateUpdate().then(() => document.location.reload());
  }
}

Support hors ligne et cache

SwPush active les notifications push web via le service worker. requestSubscription demande la permission à l'utilisateur et renvoie un objet d'abonnement à envoyer à votre serveur. Le SW reçoit les événements push même si l'onglet est fermé. Les clés VAPID authentifient votre serveur. Associez l'API Notification pour afficher des messages ; gérez les clics pour naviguer dans l'app.

angular
import { SwPush } from '@angular/service-worker';

export class NotificationComponent {
  private swPush = inject(SwPush);

  subscribeToPush() {
    this.swPush.requestSubscription({
      serverPublicKey: this.VAPID_PUBLIC,
    }).then(sub => this.sendToServer(sub))
      .catch(err => console.error('Push denied', err));
  }

  // check if SW is enabled
  ngOnInit() {
    if (!this.swPush.isEnabled) {
      console.warn('Push notifications not supported');
    }
  }
}

Manifest de l'app

Le manifest web rend l'app installable (Ajouter à l'écran d'accueil). name/short_name s'affichent sur l'écran d'accueil ; theme_color teinte l'UI du navigateur ; display: standalone retire l'habillage du navigateur pour un ressenti d'app. Fournissez plusieurs tailles d'icônes (192, 512) plus une icône maskable pour Android. Testez avec l'audit PWA de Lighthouse pour vérifier l'installabilité.

angular
<!-- index.html (added by ng add @angular/pwa) -->
<link rel="manifest" href="manifest.webmanifest">
<meta name="theme-color" content="#1976d2">
<meta name="apple-mobile-web-app-capable" content="yes">
<meta name="apple-mobile-web-app-status-bar-style" content="black">
<link rel="apple-touch-icon" href="assets/icons/icon-152x152.png">

// manifest.webmanifest
{
  "name": "My App",
  "short_name": "MyApp",
  "theme_color": "#1976d2",
  "background_color": "#fafafa",
  "display": "standalone",
  "scope": "/",
  "start_url": "/",
  "icons": [
    { "src": "assets/icons/icon-192x192.png", "sizes": "192x192", "type": "image/png" },
    { "src": "assets/icons/icon-512x512.png", "sizes": "512x512", "type": "image/png" }
  ]
}

Installabilité et Lighthouse

beforeinstallprompt se déclenche dans Chrome quand l'app est installable mais permet de différer la demande native. Enregistrez l'événement et déclenchez prompt() depuis un geste utilisateur (clic bouton). iOS Safari ne déclenche pas cet événement — les utilisateurs installent via le menu Partager. Lancez l'audit PWA de Lighthouse pour vérifier l'installabilité. Les PWA fonctionnent hors ligne seulement quand le service worker met la coquille de l'app en cache.

angular
// detect install prompt (Chrome)
let deferredPrompt: any;
window.addEventListener('beforeinstallprompt', (e) => {
  e.preventDefault();
  deferredPrompt = e;
  this.canInstall = true;   // show "Install App" button
});

// user-triggered install (must be from user gesture)
async installApp() {
  if (!deferredPrompt) return;
  deferredPrompt.prompt();
  const { outcome } = await deferredPrompt.userChoice;
  console.log('Install:', outcome);
  deferredPrompt = null;
}

// Lighthouse PWA checklist:
// ✅ served over HTTPS
// ✅ registers a service worker
// ✅ has a web manifest with icons
// ✅ start_url loads offline
18

Composants standalone

Amorçage standalone

bootstrapApplication démarre une app standalone — pas de NgModule nécessaire. Le AppComponent racine doit être standalone. app.config.ts centralise les providers (routeur, http, animations, config de zone). C'est le défaut depuis la v17. Chaque fonction provideX() câble un sous-système. Bien plus propre que AppModule + providers d'AppModule.

angular
// main.ts
import { bootstrapApplication } from '@angular/platform-browser';
import { appConfig } from './app/app.config';
import { AppComponent } from './app/app.component';

bootstrapApplication(AppComponent, appConfig)
  .catch(err => console.error(err));

// app.config.ts
import { ApplicationConfig, provideZoneChangeDetection } from '@angular/core';
import { provideRouter } from '@angular/router';
import { provideHttpClient } from '@angular/common/http';
import { routes } from './app.routes';

export const appConfig: ApplicationConfig = {
  providers: [
    provideZoneChangeDetection({ eventCoalescing: true }),
    provideRouter(routes),
    provideHttpClient(),
  ],
};

Imports des composants standalone

standalone: true marque le composant comme autonome. Le tableau imports liste tout ce dont le template a besoin : modules, composants, directives, pipes. Avec le flux de contrôle v17+ (@if/@for), pas besoin de CommonModule pour cela. N'importez que l'employé pour un meilleur tree-shaking. Les composants standalone peuvent s'employer dans des NgModules via exports.

angular
@Component({
  selector: 'app-user-list',
  standalone: true,
  imports: [
    CommonModule,          // *ngIf, *ngFor, pipes (or use built-in @if/@for)
    FormsModule,           // ngModel
    UserCardComponent,     // another standalone component
    HighlightDirective,    // standalone directive
    TruncatePipe,          // standalone pipe
  ],
  template: `
    <input [(ngModel)]="filter" />
    @for (u of users; track u.id) {
      <app-user-card [user]="u" appHighlight>{{ u.name | truncate:20 }}</app-user-card>
    }
  `,
})
export class UserListComponent { ... }

Routes standalone et chargement paresseux

loadComponent charge paresseusement un seul composant standalone — le plus petit chunk possible. loadChildren charge paresseusement un fichier de routes (export par défaut de Routes). Les deux emploient dynamic import() avec un chemin statique pour que le bundler découpe. Cela remplace entièrement les modules de fonctionnalités. Chaque route paresseuse reçoit son propre fichier JS, chargé à la première navigation.

angular
export const routes: Routes = [
  { path: '', loadComponent: () => import('./home/home.component')
      .then(m => m.HomeComponent) },
  {
    path: 'admin',
    loadComponent: () => import('./admin/admin.component')
      .then(m => m.AdminComponent),
    canMatch: [authGuard],
  },
  {
    path: 'reports',
    loadChildren: () => import('./reports/reports.routes')
      .then(m => m.REPORTS_ROUTES),
  },
];

Directives et pipes standalone

Les directives et pipes peuvent aussi être standalone (v15+). Ajoutez standalone: true et importez-les dans tout composant qui en a besoin. Cela élimine le besoin de les déclarer dans un module partagé. Pour la compatibilité ascendante, les directives/pipes standalone peuvent encore s'ajouter aux exports d'un NgModule pour les employer dans des composants à base de NgModule.

angular
@Directive({
  selector: '[appHighlight]',
  standalone: true,
})
export class HighlightDirective { ... }

@Pipe({
  name: 'truncate',
  standalone: true,
})
export class TruncatePipe implements PipeTransform { ... }

// use directly in a standalone component's imports
@Component({
  imports: [HighlightDirective, TruncatePipe],
  template: `<p appHighlight>{{ text | truncate:10 }}</p>`,
})

Migrer depuis NgModule

Le schematic automatise la migration : il rend toutes les déclarations standalone, déplace les imports du NgModule vers le tableau imports de chaque composant, et retire les modules obsolètes. Lancez-le par incréments — il peut être partiel. Après migration, vous pouvez supprimer AppRoutingModule, AppModule et employer bootstrapApplication. Le résultat est une app plus légère et mieux tree-shakeable.

angular
# automatic migration (v15.2+)
ng generate @angular/core:standalone

# options:
# 1. Convert all components/directives/pipes to standalone
# 2. Remove unnecessary NgModule classes
# 3. Bootstrap the app using bootstrapApplication

// before: declared in a module
@NgModule({
  declarations: [OldComponent],
  imports: [CommonModule],
  exports: [OldComponent],
})
export class OldModule {}

// after: standalone component
@Component({
  standalone: true,
  imports: [CommonModule],
  // ...
})
export class OldComponent {}

Injection dans les providers standalone

Les apps standalone configurent les providers dans app.config.ts au lieu d'AppModule. APP_INITIALIZER exécute la configuration avant l'amorçage. Les providers au niveau composant se bornent au sous-arbre de ce composant. Pour les services, providedIn: 'root' reste préféré — tree-shakeable. Employez les tableaux providers pour les valeurs hors services (tokens, configs, mocks).

angular
// app.config.ts — global providers
export const appConfig: ApplicationConfig = {
  providers: [
    { provide: API_URL, useValue: 'https://api.example.com' },
    { provide: ErrorHandler, useClass: GlobalErrorHandler },
    { provide: APP_INITIALIZER, multi: true, useFactory: () => initApp },
  ],
};

// component-level providers (scoped to this component and children)
@Component({
  providers: [
    { provide: UserService, useClass: MockUserService },
  ],
})
export class AdminComponent {}

// tree-shakable service
@Injectable({ providedIn: 'root' })  // preferred over providers array
export class AuthService {}
19

Signaux

Créer des signaux

signal() crée une valeur réactive. On lit en l'appelant : count(). On met à jour avec set() (remplacer) ou update() (calculer depuis le précédent). Les signaux sont synchrones et évitent la surcharge des Observables pour l'état simple. Dans les templates, on peut les appeler avec () — la v17.2+ auto-déballe aussi dans certains contextes. Les signaux s'intègrent à la détection de changements OnPush.

angular
import { signal, computed, effect } from '@angular/core';

export class CounterComponent {
  // writable signal with initial value
  count = signal(0);
  user = signal<User | null>(null);

  // reading: call the signal as a function
  current = this.count();    // 0

  // writing
  increment() { this.count.update(v => v + 1); }
  setFive() { this.count.set(5); }

  // in templates, signals are called automatically in v17.2+
  // {{ count }} or {{ count() }} both work in templates
}

Signaux calculés

computed() crée un signal dérivé en lecture seule qui suit automatiquement ses dépendances et met sa valeur en cache. Il ne recalcule que quand une dépendance change ET qu'on le relit — évaluation paresseuse. Les signaux calculés peuvent dépendre d'autres signaux calculés, formant un graphe. Contrairement aux méthodes, ils mettent les résultats en cache. Cela remplace bien des usages de RxJS combineLatest.

angular
export class CartComponent {
  items = signal<Item[]>([]);
  taxRate = signal(0.08);

  // derived state — recomputes only when items or taxRate change
  subtotal = computed(() =>
    this.items().reduce((sum, i) => sum + i.price * i.qty, 0)
  );
  tax = computed(() => Math.round(this.subtotal() * this.taxRate() * 100) / 100);
  total = computed(() => this.subtotal() + this.tax());

  // computed signals are readonly and cached
  // they recompute lazily only when read AND a dependency changed
}

Effets (effets de bord)

effect() exécute un effet de bord quand ses dépendances de signaux changent. Employez-le pour logger, synchroniser en localStorage, fetcher des données ou manipuler le DOM. Les effets tournent après la détection de changements. Évitez d'écrire dans des signaux lus dans le même effet — boucle infinie. onCleanup enregistre la logique de démontage pour le prochain tour. Les effets doivent se créer dans un contexte d'injection.

angular
export class SearchComponent {
  query = signal('');
  results = signal<Result[]>([]);

  constructor() {
    // effect runs when its signal dependencies change
    effect(() => {
      const q = this.query();
      // ⚠️ avoid setting signals read in this effect (causes loops)
      this.search(q).then(r => this.results.set(r));
    });
  }

  // effect with cleanup
  private log = effect((onCleanup) => {
    const id = setInterval(() => console.log(this.count()), 1000);
    onCleanup(() => clearInterval(id));
  });
}

Signaux dans les templates (OnPush)

Les signaux s'intègrent sans couture à OnPush — Angular sait exactement quelles vues dépendent d'un signal et ne marque que celles-ci pour vérification quand il change. Pas de markForCheck() manuel. Dans les templates, appelez les signaux avec () pour lire. OnPush + signaux est la configuration de détection de changements la plus efficace, permettant souvent d'abandonner entièrement zone.js (mode zoneless).

angular
@Component({
  selector: 'app-todo',
  // signals work great with OnPush — automatic efficiency
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: `
    <input (input)="text.set($any($event.target).value)" />
    <p>You typed: {{ text() }}</p>
    <p>Length: {{ length() }}</p>
    <button (click)="clear()">Clear</button>
  `,
})
export class TodoComponent {
  text = signal('');
  length = computed(() => this.text().length);
  clear() { this.text.set(''); }
}

Inputs et requêtes à signaux

input()/input.required() créent des inputs à signaux en lecture seule. output() crée des sorties typées. model() crée des inputs à signaux liables bidirectionnellement (avec output xChange auto-généré). viewChild()/contentChild() renvoient des signaux qui se résolvent après l'init de la vue — appelez-les avec () pour lire. Ces API modernes remplacent les décorateurs @Input/@Output/@ViewChild par des signaux réactifs.

angular
import { input, output, viewChild, contentChild, model } from '@angular/core';

export class EditComponent {
  // signal input (readonly, v17.1+)
  id = input<number>(0);
  requiredName = input.required<string>();

  // signal output (v17.3+)
  saved = output<User>();

  // two-way signal (v17.2+)
  value = model<number>(0);   // creates input + output named valueChange

  // signal queries
  inputEl = viewChild<ElementRef>('input');      // in own template
  header = contentChild<TemplateRef>('header');  // projected content

  focus() { this.inputEl()?.nativeElement.focus(); }
}

Signaux et interop RxJS

toSignal convertit un Observable en signal (s'abonne une fois, se désabonne à la destruction). toObservable fait l'inverse. Employez l'interop pour mélanger signaux (état synchrone) et RxJS (flux asynchrones complexes comme la recherche debouncée). takeUntilDestroyed se désabonne automatiquement via DestroyRef. initialValue prévient les lectures undefined avant la première émission. Exige un contexte d'injection.

angular
import { toSignal, toObservable, takeUntilDestroyed } from '@angular/core/rxjs-interop';

export class SearchComponent {
  private http = inject(HttpClient);

  // Observable → Signal (one-way)
  results = toSignal(this.http.get<Result[]>('/api/results'), {
    initialValue: [] as Result[],
  });

  // Signal → Observable (for RxJS operators)
  private query$ = toObservable(this.query);

  // combine the best of both worlds
  filtered = toSignal(
    this.query$.pipe(
      debounceTime(300),
      switchMap(q => this.http.get(`/api/search?q=${q}`)),
      takeUntilDestroyed(),
    ),
    { initialValue: [] as Result[] },
  );
}
20

NgModules et architecture

Structure de NgModule

Les NgModules organisent l'app en blocs cohésifs. declarations liste ce que le module possède. imports fait entrer les exports d'autres modules. exports expose les déclarations aux importateurs. Seul le module racine règle bootstrap. L'Angular moderne privilégie les composants standalone (sans NgModule), mais les apps à NgModule existent toujours. Comprenez les deux — les anciennes bases de code et certaines bibliothèques emploient des modules.

angular
@NgModule({
  declarations: [                  // components, directives, pipes owned by this module
    AppComponent,
    UserListComponent,
    HighlightDirective,
    TruncatePipe,
  ],
  imports: [                       // other modules whose exports this module needs
    BrowserModule,
    FormsModule,
    HttpClientModule,
    AppRoutingModule,
  ],
  exports: [                       // what's visible to modules that import this module
    UserListComponent,
    TruncatePipe,
  ],
  providers: [],                   // services (use providedIn: 'root' instead)
  bootstrap: [AppComponent],       // only in the root module
})
export class AppModule {}

Modules de fonctionnalités et partagés

SharedModule regroupe composants/directives/pipes UI communs pour la réutilisation entre fonctionnalités — re-exportez CommonModule et FormsModule pour que les importateurs n'aient pas à le faire. Les modules de fonctionnalités encapsulent une zone ; forChild() laisse le même module se configurer différemment par import (ex. le routage). Dans les apps standalone, préférez les composants standalone individuels aux modules partagés.

angular
// shared.module.ts — reusable UI bits
@NgModule({
  imports: [CommonModule, FormsModule],
  declarations: [ButtonComponent, CardComponent, HighlightDirective],
  exports: [ButtonComponent, CardComponent, HighlightDirective, FormsModule],
})
export class SharedModule {}

// feature module (lazy-loaded)
@NgModule({
  declarations: [AdminComponent, AdminUsersComponent],
  imports: [CommonModule, RouterModule, SharedModule],
  exports: [AdminComponent],
})
export class AdminModule {
  static forChild(): ModuleWithProviders<AdminModule> {
    return { ngModule: AdminModule, providers: [AdminService] };
  }
}

Core module et services singletons

CoreModule porte les singletons de l'app (services, intercepteurs, gestionnaires d'erreurs) et s'importe une fois dans AppModule. Le garde du constructeur prévient la ré-importation accidentelle (qui créerait des instances de services dupliquées). Dans les apps standalone, ces providers migrent vers app.config.ts. Le pattern CoreModule est un héritage mais on le croise dans les bases de code d'avant la v14.

angular
// core.module.ts — app-wide singletons, imported once in AppModule
@NgModule({
  providers: [
    AuthService,
    { provide: HTTP_INTERCEPTORS, useClass: AuthInterceptor, multi: true },
    { provide: ErrorHandler, useClass: GlobalErrorHandler },
  ],
})
export class CoreModule {
  // guard against importing twice
  constructor(@Optional() @SkipSelf() parent?: CoreModule) {
    if (parent) throw new Error('CoreModule already loaded');
  }
}

Pattern forRoot vs forChild

forRoot configure l'instance racine (appelé une fois dans AppModule) ; forChild enregistre les routes enfants (appelé dans les modules de fonctionnalités). Ce pattern est employé par RouterModule et les modules de bibliothèque exigeant de la configuration. L'Angular moderne le remplace par des fonctions provideX() dans app.config.ts. Le pattern apparaît encore dans les bibliothèques tierces — comprenez-le pour l'intégration.

angular
// classic RouterModule pattern
@NgModule({ imports: [CommonModule], exports: [RouterModule] })
export class RouterModule {
  static forRoot(routes: Routes): ModuleWithProviders<RouterModule> {
    return {
      ngModule: RouterModule,
      providers: [provideRouter(routes)],
    };
  }
  static forChild(routes: Routes): ModuleWithProviders<RouterModule> {
    return { ngModule: RouterModule, providers: [provideRoutes(routes)] };
  }
}

// AppModule imports: RouterModule.forRoot(ROUTES)
// FeatureModule imports: RouterModule.forChild(FEATURE_ROUTES)

// modern equivalent: provideRouter(routes) in app.config.ts

Entry components et dynamique

entryComponents (déprécié) listait les composants créés dynamiquement (dialogues, modales). L'Angular moderne emploie ViewContainerRef.createComponent() ou NgComponentOutlet — pas d'enregistrement nécessaire. Cela fonctionne sans couture avec les composants standalone. createComponent renvoie un ComponentRef avec .instance et .destroy(). Nettoyez en appelant destroy() pour éviter les fuites.

angular
// older API: entryComponents for dynamically created components
@NgModule({
  entryComponents: [DialogComponent, ModalComponent],
})
export class AppModule {}

// modern: ViewContainerRef.createComponent (no entryComponents needed)
export class DialogService {
  constructor(private vcr: ViewContainerRef) {}

  open() {
    const ref = this.vcr.createComponent(DialogComponent);
    ref.instance.title = 'Hello';
    ref.instance.close.subscribe(() => ref.destroy());
    return ref;
  }
}

// even simpler: NgComponentOutlet in template
<ng-container *ngComponentOutlet="dialogComponent; inputs: { title: 'Hi' }" />

Modules à chargement paresseux

Les modules à chargement paresseux créent un chunk JS séparé chargé à la navigation. Le dynamic import() doit être une chaîne statique pour que le bundler découpe. Les modules paresseux ont leur propre injecteur racine — les services avec providedIn dans un module paresseux ne sont pas singletons dans toute l'app. Les apps standalone modernes emploient loadComponent/loadChildren avec des fichiers de routes à la place, plus simple et plus granulaire.

angular
// classic lazy module (pre-standalone)
const routes: Routes = [
  {
    path: 'admin',
    loadChildren: () => import('./admin/admin.module').then(m => m.AdminModule),
  },
];

// admin-routing.module.ts
const routes: Routes = [
  { path: '', component: AdminComponent },
  { path: 'users', component: AdminUsersComponent },
];

@NgModule({
  imports: [RouterModule.forChild(routes)],
  exports: [RouterModule],
})
export class AdminRoutingModule {}

// admin.module.ts
@NgModule({
  declarations: [AdminComponent, AdminUsersComponent],
  imports: [CommonModule, AdminRoutingModule],
})
export class AdminModule {}

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.