AngularAtlaséd. 22.2

Chap. 11Qualité et performance52 / 75

DevTools : regarder dans votre application

Chrome DevTools et Angular DevTools pas à pas : ce que montre chaque panneau, avec des exercices qui fonctionnent sur ce site.

Chrome DevTools est intégré au navigateur et fonctionne sur n’importe quel site, y compris les applications publiées. Il vous montre le DOM, les requêtes, ce qui est stocké dans le navigateur, ce que consomme la page et ce qui reste en mémoire. Angular DevTools est une extension à part, qui ajoute un onglet « Angular » avec l’arbre des composants, le profiler, les injecteurs et les routes.

Les étapes ci-dessous utilisent les noms exacts des boutons de Chrome DevTools, tirés de son code source. Chaque section propose un exercice à faire directement sur cette page.

En bref
  • Sur un site publié (build de production), les noms de classes sont minifiés, window.ng n’existe pas et Angular DevTools refuse de démarrer. Pour cela, il vous faut votre propre application, lancée avec ng serve.
  • Elements, Network, Application, Performance monitor et les heap snapshots fonctionnent partout. Cherchez par balises et types natifs, pas par vos noms de classes.
  • Une fuite se voit comme un nombre qui augmente à chaque répétition et ne redescend jamais : JS event listeners dans Performance monitor, un # Delta positif dans Comparison.
  • DevTools lui-même peut garder des objets en vie : ce que vous avez sélectionné dans Elements ou affiché dans la Console. Videz la console avant le dernier snapshot.
Pourquoi vous ne voyez rien sur un site publié
  • Les noms de classes sont minifiés. Un heap snapshot ne montre pas LeakyWidget mais e, Ge ou dc. Les balises HTML (<app-leaky-widget>) et les types natifs du navigateur (DOMTimer, EventListener) restent en revanche lisibles.
  • Les utilitaires ng.* de la console n’existent qu’en développement. Sur le site publié, ng vaut undefined.
  • Angular DevTools ne fonctionne pas sur les builds de production. Il affiche « We detected an application built with production configuration. Angular DevTools only supports development builds. »
  • Les exemples HTTP de ce site utilisent un backend simulé dans le navigateur. Leurs requêtes n’arrivent jamais dans Network. Le laboratoire ci-dessous envoie une vraie requête, pour que vous ayez quelque chose à suivre.

Ouvrir DevTools et trouver n’importe quel panneau

  • Ouvrez DevTools avec F12 ou Ctrl+Shift+I (Windows, Linux), ou Cmd+Option+I (Mac). Ou clic droit sur la page → Inspect (Inspecter).
  • Les panneaux sont des onglets en haut : Elements, Console, Sources, Network, Performance, Memory, Application. Ceux qui ne tiennent pas sont sous ».
  • Le chemin le plus rapide vers tout : le menu de commandes, avec Ctrl+Shift+P ou Cmd+Shift+P. Tapez « memory » et choisissez Show Memory, ou « performance monitor » et choisissez Show Performance monitor.
  • Esc ouvre et ferme le drawer du bas, avec la Console. Vous voyez ainsi la console à côté de n’importe quel autre panneau.

S’exercer sur cette page

Gardez DevTools ouvert à côté de la page. Chaque carte dit ce que vous appuyez ici et ce que vous cherchez là-bas.

LiveQuatre exercices pour Elements, Console, Network et Application

Elements

Cliquez sur l’icône d’inspection dans le coin de DevTools (ou Ctrl+Shift+C / Cmd+Shift+C) puis sur le texte gris à côté du bouton. Appuyez ensuite plusieurs fois sur +1 : dans Elements, l’attribut data-clicks clignote à chaque changement.

data-clicks="0"

Console

Appuyez sur le bouton, puis tapez atlas dans le champ Filter de la Console. Cliquez sur la flèche devant l’objet pour le déplier.

Network

Dans Network, choisissez le filtre Fetch/XHR et appuyez sur le bouton. Une ligne robots.txt?atlas-lab=1 apparaît. Cliquez dessus et parcourez Headers, Response et Timing.

Réglez le throttling sur Slow 4G et envoyez de nouveau : le temps augmente, et Timing montre où il passe.

Application

Enregistrez un texte, puis ouvrez Application → Storage → Local storage → l’adresse du site. Double-cliquez sur la valeur de la clé atlas-devtools-lab, modifiez-la, puis appuyez sur Relire.

Ce qu’il y a maintenant dans localStorage : null

La clé atlas-progress s’y trouve aussi : votre progression dans les leçons, gardée uniquement dans votre navigateur.

Tous fonctionnent aussi sur le site publié : rien ne dépend des noms de classes.

Elements : ce qu’Angular a rendu

Elements montre le DOM tel qu’il est maintenant, pas le HTML envoyé par le serveur. Quelques traces qu’Angular y laisse :

  • L’élément racine (<app-root>) porte un attribut ng-version avec la version exacte d’Angular. Sur ce site : 22.2.2.
  • Les attributs _nghost-ng-c… et _ngcontent-ng-c… viennent de l’encapsulation des styles (mode Emulated). Dans le volet Styles à droite, les sélecteurs ressemblent à .btn[_ngcontent-ng-c…].
  • Les commentaires vides <!----> sont les ancres d’Angular pour @if, @for et @defer : l’endroit où il insère ou retire du contenu.
  • L’élément sélectionné est disponible dans la Console sous le nom $0. Les attributs et le texte qui changent clignotent un instant dans Elements : c’est ainsi que vous voyez ce qu’Angular met à jour.

Console : les utilitaires ng (développement uniquement)

Dans votre application lancée avec ng serve, Angular place un objet global ng dans la page. Sélectionnez un élément dans Elements, puis dans la Console :

// Elements : sélectionnez un élément ; dans la Console c’est $0 (développement uniquement)
ng.getComponent($0)          // le composant dont $0 est l’hôte
ng.getOwningComponent($0)    // le composant dont le template contient $0
ng.getDirectives($0)         // les directives sur $0
ng.getInjector($0)           // l’injecteur de l’élément : .get(UnService)
ng.getListeners($0)          // les listeners posés par Angular sur $0
ng.getRootComponents()       // les composants racines

const c = ng.getComponent($0);
c.count.set(42);             // un signal s’écrit directement ; Angular rend tout seul
c.title = 'Test';            // une propriété simple a besoin d’applyChanges
ng.applyChanges(c);

Sur un build de production, ces fonctions n’existent pas. Ce n’est pas un bug : elles sont retirées exprès pour ne pas alourdir l’application.

Network : ce que l’application demande

Network n’enregistre que tant qu’il est ouvert. Si vous l’ouvrez après le chargement de la page, rechargez-la.

  • Les filtres en haut (Fetch/XHR, JS, CSS, Img…) et le champ texte ne laissent que les requêtes qui vous intéressent.
  • Cliquez sur une requête : Headers (URL, statut, en-têtes), Payload (ce que vous avez envoyé), Preview et Response (ce qui est revenu), Initiator (le code qui l’a lancée), Timing (où le temps est passé).
  • Keep log (dans les anciennes versions : Preserve log) garde la liste à la navigation et au rechargement. Disable cache contourne le cache tant que DevTools est ouvert.
  • Le menu Throttling simule un réseau plus lent : Fast 4G, Slow 4G, 3G ou Offline. Vous voyez ainsi les skeletons, les états de chargement et ce qui se passe sans réseau.

Application : ce que l’application garde dans le navigateur

  • Storage → Local storage / Session storage → l’adresse du site : les clés et valeurs, que vous pouvez modifier ou supprimer.
  • Cookies, IndexedDB et Cache storage sont au même endroit. Cache storage est l’endroit où un Service Worker garde les fichiers pour le hors-ligne.
  • La section Service workers montre le worker actif. Update on reload force la nouvelle version à chaque rechargement, et Bypass for network le contourne. Les deux sont pratiques pendant que vous travaillez dessus.
  • Storage → Clear site data efface tout ce que le site a enregistré. C’est le moyen le plus sûr de tester une « première visite ».

Performance monitor : la vérification rapide

Avant tout snapshot, regardez les chiffres en direct :

  1. Menu de commandes (Ctrl/Cmd+Shift+P) → « performance monitor » → Show Performance monitor. Il s’ouvre en bas, dans le drawer.
  2. Surveillez JS heap size, DOM nodes et JS event listeners. Un clic sur un nom affiche ou masque sa courbe.
  3. Dans le laboratoire ci-dessous, correctifs décochés, appuyez sur Ouvrir et fermer 10 fois. JS event listeners augmente de 10 et y reste. Appuyez sur Nettoyer les zombies : il redescend. Avec tous les correctifs cochés, il n’augmente pas du tout.

Memory : une fuite trouvée pas à pas

Le laboratoire de la leçon sur les fuites mémoire, ici, pour que vous ayez quelque chose à mesurer. Chaque widget fermé avec les correctifs décochés laisse derrière lui un timer, un listener et un abonnement qui gardent le composant en mémoire.

LiveDes widgets qui fuient
Fermer au destroy :

Aucun widget sur la page.

détruits, encore en vie
0
mémoire retenue
0.00 MB
travail des zombies
0/s
abonnements
0
timers
0
listeners
0
widgets créés
0
Décochez les correctifs, appuyez sur Ouvrir et fermer 10 fois, puis suivez les étapes ci-dessous.

Heap snapshot et Comparison

  1. Ouvrez le panneau Memory. Sous Select profiling type, choisissez Heap snapshot.
  2. Cliquez sur l’icône de corbeille, Collect garbage, puis sur Take snapshot. Snapshot 1 apparaît à gauche.
  3. Sur la page, correctifs décochés, appuyez sur Ouvrir et fermer 10 fois et attendez la fin.
  4. De nouveau Collect garbage et Take snapshot : Snapshot 2 apparaît.
  5. Snapshot 2 sélectionné, passez le premier menu de la barre du haut de Summary à Comparison. Le menu voisin indique avec quoi vous comparez : Snapshot 1.
  6. Tapez un nom du tableau ci-dessous dans Filter by class et regardez les colonnes # New et # Delta.
  7. Appuyez sur Nettoyer les zombies, prenez Snapshot 3 et comparez-le à Snapshot 2 : les mêmes lignes apparaissent maintenant sous # Deleted.
Filter by class# DeltaCe que cela signifie
app-leaky-widget+10Les éléments hôtes des 10 widgets, retirés de la page mais toujours gardés en mémoire. Visible aussi sur le site publié.
DOMTimer+10Les 10 setInterval qui tournent encore. C’est un type natif du navigateur, donc le nom reste lisible en production aussi.
EventListener+10Les listeners ajoutés sur document et jamais retirés.
LeakyWidget+10La classe du composant. N’apparaît qu’en développement (en général sous la forme _LeakyWidget). En production le nom est minifié : là, cherchez par balise.

Qui garde l’objet : Retainers

Dépliez une ligne et cliquez sur une instance. Le volet Retainers en bas montre qui la garde en vie : les lignes du haut sont les références directes, et en les dépliant vous remontez la chaîne vers quelque chose qui vit longtemps (Window, un listener, un timer). La colonne Distance indique à combien d’étapes se trouve window. La fuite, c’est le maillon que votre code aurait dû rompre à la destruction.

Plus direct : Detached elements

  1. Dans Memory → Select profiling type, choisissez Detached elements.
  2. Répétez l’action sur la page, puis appuyez sur Get detached elements.
  3. La liste montre les éléments retirés de la page mais encore référencés depuis JavaScript. Ici : un <app-leaky-widget> par widget fermé.
DevTools garde lui aussi des objets en vie
Un élément sélectionné dans Elements, un objet affiché avec console.log ou un résultat dans la Console restent en mémoire tant que DevTools en a besoin. Si un snapshot montre encore des objets après le nettoyage, videz la console (l’icône de cercle barré, ou Ctrl+L, sur Mac Cmd+K), sélectionnez un autre élément et recommencez. Dans Summary, le filtre Objects retained by DevTools Console montre exactement ces objets.

Performance : ce qui se passe dans le temps

  • Record enregistre pendant que vous faites quelque chose sur la page. Record and reload recharge la page et enregistre le démarrage.
  • Cochez Show memory timeline pour voir le heap JS, les documents, les nœuds et les listeners sur le même axe. Une fuite ressemble à un escalier qui monte et ne redescend jamais.
  • En développement, Angular peut ajouter sa propre piste Angular, avec composants, change detection et hooks. Activez-la avec ng.enableProfiling() dans la Console, avant Record.
// dans la Console, dans votre application lancée avec ng serve :
ng.enableProfiling();

// ou dans main.ts, pour capter aussi le démarrage :
import { enableProfiling } from '@angular/core';

enableProfiling();
bootstrapApplication(App, appConfig);

Angular DevTools

L’extension voit l’application comme Angular la voit : composants, inputs, signals, injecteurs, routes.

  1. Installez Angular DevTools depuis le Chrome Web Store (il existe aussi pour Firefox).
  2. Lancez votre application avec ng serve, ouvrez DevTools et cherchez l’onglet Angular, éventuellement sous ». Les extensions ne tournent pas sur la page « Nouvel onglet » du navigateur.
  3. Sur un build de production, ce site compris, vous verrez seulement le message « We detected an application built with production configuration ». C’est normal.
OngletCe que vous voyez
ComponentsL’arbre des composants et directives, y compris les blocs @defer. Cliquez sur un composant : inputs, outputs et propriétés à droite. Clic droit sur une valeur pour la modifier.
ProfilerChaque cycle de change detection sous forme de barre ; plus elle est haute, plus il a duré. On démarre avec le cercle en haut à gauche (Start recording). La case Change detection montre quels composants ont réellement été vérifiés.
Injector TreeLa hiérarchie des injecteurs d’environnement et d’élément et le chemin que suit la recherche d’une dépendance (Angular 17+).
Router TreeL’arbre des routes : path, composant, guards, resolvers, lazy ou non, laquelle est active.
  • $ng0 dans la Console est le composant sélectionné dans Angular DevTools, $ng1 le précédent.
  • L’icône d’inspection dans le coin de l’extension : survolez la page et voyez quel composant s’y trouve.
  • Un double-clic sur un composant vous mène à son élément dans Elements ; l’icône en haut à droite, à sa source dans Sources.
  • Show Signal Graph, en tête du volet des propriétés, dessine les signals, computeds et effects du composant et qui lit qui (Angular 19+). Donnez-leur un debugName pour qu’ils aient des noms lisibles.

Les sources habituelles de fuites et comment fermer chacune sont dans Fuites mémoire. Que faire une fois trouvé ce qui est lent : Performance et Change detection.

Pièges fréquents

  • Chercher le nom de votre classe sur un build de production. Il n’y est pas : cherchez par balise ou type natif, ou lancez l’application avec ng serve.
  • Comparer des snapshots sans Collect garbage avant : le heap monte et descend tout seul, et les petites différences ne veulent rien dire.
  • Répéter l’action une seule fois. Une fuite est un nombre qui augmente du même pas à chaque répétition. Répétez 10 fois et cherchez +10.
  • Ouvrir Network après le chargement de la page et croire que rien n’a été demandé. Network n’enregistre que tant qu’il est ouvert : rechargez la page.

Aide-mémoire

F12 · Ctrl+Shift+I · Cmd+Option+I            ouvrir DevTools
Ctrl+Shift+C · Cmd+Shift+C                   choisir un élément dans la page
Ctrl+Shift+P · Cmd+Shift+P                   le menu de commandes
Esc                                          le drawer avec la Console

Network       Fetch/XHR · Keep log · Disable cache · Throttling
Application   Storage → Local storage · Service workers · Clear site data
Perf monitor  JS heap size · DOM nodes · JS event listeners
Memory        Heap snapshot → Take snapshot → Comparison → Filter by class
Memory        Detached elements → Get detached elements
Performance   Record · Record and reload · Show memory timeline

développement uniquement :
  ng.getComponent($0) · ng.applyChanges(c) · ng.enableProfiling()
  Angular DevTools: Components · Profiler · Injector Tree · Router Tree · $ng0

Chap. 11 · 0 sur 4 terminées

Leçon terminée ?

Marquez-la : elle apparaîtra sur votre carte, dans le sommaire et sur la page d’accueil.

Se marque toute seule une fois la leçon lue en entier.

  1. Performance — une checklist
  2. Tests avec Vitest
  3. DevTools : regarder dans votre application
  4. Angular Aria
Voir toute votre carte

Les 75 pages · tapez pour filtrer

  • 01Nouveautés d’Angular 21 & 22Tous les changements importants de la v21 et de la v22, en bref, avec un lien vers la page qui explique chacun.Départ
  • 01Votre première application, pas à pasUne liste de lecture construite d’un composant vide jusqu’à une application terminée — signals, @for, inputs et outputs, un service et un formulaire, pas à pas.Départ
  • 01Décisions rapides« Où mettre ça ? », « Signal ou Observable ? », « Shared ou feature ? » — des réponses courtes aux questions de tous les jours.Départ
  • 01Questions d’entretien Angular60 vraies questions d’entretien pour profils junior, confirmé et senior, avec la réponse à donner, la relance et les signaux d’alerte. Plus un entretien blanc.Départ
  • 02Standalone et bootstrapComment une application démarre sans NgModule : bootstrapApplication, app.config.ts, imports dans le composant.Fondamentaux modernes
  • 02Data binding et événementsInterpolation, bindings de propriétés et d’attributs, événements avec $event et filtres de touches, et comment [( )] est construit — ce qui entre dans le DOM et ce qui en revient.Fondamentaux modernes
  • 02Control Flow : @if, @for, @switchLa syntaxe de blocs qui remplace *ngIf/*ngFor/ngSwitch, avec track, @empty et vérifications d’exhaustivité.Fondamentaux modernes
  • 02@let et les nouvelles expressions de templateVariables locales avec @let, fonctions fléchées, spread, regex, instanceof, commentaires dans les balises.Fondamentaux modernes
  • 02@defer — Lazy Loading dans les templatesChargez les composants lourds uniquement quand c’est nécessaire : triggers, prefetch, placeholder, loading, error.Fondamentaux modernes
  • 02Bindings de classe et de stylePourquoi [class.x] et [style.x] ont remplacé ngClass et ngStyle (avec migration automatique depuis la v21).Fondamentaux modernes
  • 02Styles des composants et encapsulation:host, les trois modes d’encapsulation, les thèmes avec des variables CSS, et pourquoi ::ng-deep est un dernier recours.Fondamentaux modernes
  • 02Pipes : quand et commentPipes pures vs impures, pipes personnalisées, et comment choisir entre une pipe, computed() et une méthode.Fondamentaux modernes
  • 03signal() et computed()Les primitives réactives : état modifiable, état dérivé, égalité, untracked et règles d’immutabilité.Signals et réactivité
  • 03effect() — quand OUI, quand NONEffets de bord synchronisés avec les Signals : localStorage, logs, API impératives. Et leurs pièges.Signals et réactivité
  • 03linkedSignal() — état dérivé modifiableUn signal qui se réinitialise quand sa source change, mais que vous pouvez aussi modifier à la main.Signals et réactivité
  • 03resource, rxResource, httpResourceDes données asynchrones sous forme de Signals : status, value, error, reload, annulation automatique. Stable depuis la v22.Signals et réactivité
  • 03debounced() — signals différésLa version « debounce » d’un signal, sans RxJS. Parfait pour la recherche.Signals et réactivité
  • 03Listes : rechercher, filtrer, trier, paginerUne chaîne de signals computed qui ne recalcule que ce qui a changé, avec les filtres dans l’URL pour qu’un lien rouvre la même vue.Signals et réactivité
  • 03Les Observables depuis zéroCe qu’est un Observable, subscribe et unsubscribe, les opérateurs que vous utilisez chaque semaine, froid ou chaud — et quand un signal suffit.Signals et réactivité
  • 03Signals ↔ RxJStoSignal, toObservable, takeUntilDestroyed, outputFromObservable — et quand RxJS reste le bon choix.Signals et réactivité
  • 04input() et output()Les inputs comme Signals (required, transform, alias) et les outputs typés. Les données descendent, les événements remontent.Composants : communication
  • 04model() — binding bidirectionnelLe « banana-in-a-box » [( )] avec une seule API. Quand l’utiliser, et quand input + output est préférable.Composants : communication
  • 04viewChild et contentChildLes queries comme Signals : viewChild, viewChildren, contentChild, contentChildren, l’option read.Composants : communication
  • 04Lifecycle et DestroyRefQuels hooks comptent encore à l’ère des Signals, afterNextRender, DestroyRef et ngOnChanges typé.Composants : communication
  • 04Projection de contenung-content avec select, plusieurs slots, contenu par défaut et le piège de la projection conditionnelle.Composants : communication
  • 04ng-template et ngTemplateOutletLes templates comme valeurs : les render props en Angular, contexte typé et personnalisation des composants.Composants : communication
  • 05Smart vs DumbContainer vs présentation : qui détient l’état, qui se contente d’afficher, et comment bien les séparer.Conception des composants
  • 05Composants génériques <T>Un DataTable<T> ou un Select<T> correctement typé, avec des templates pour les cellules.Conception des composants
  • 05Composants dynamiquesNgComponentOutlet, createComponent avec inputBinding/outputBinding, et un tableau de bord construit à partir d’une configuration.Conception des composants
  • 05Directives et composition d’hôteLes directives d’attribut, les métadonnées host: {} et la Directive Composition API (hostDirectives).Conception des composants
  • 05Contrôles de formulaire personnalisésFormValueControl (Signal Forms) vs ControlValueAccessor : une notation par étoiles, dans les deux variantes.Conception des composants
  • 05Change DetectionOnPush est la valeur par défaut depuis la v22, Zone.js a disparu depuis la v21. Ce qui déclenche le rendu et comment éviter les mauvaises surprises.Conception des composants
  • 06inject() et @Service()Le nouveau décorateur @Service() de la v22, inject() vs le constructeur, et le contexte d’injection.Dependency Injection
  • 06Providers et hiérarchie des injecteursRoot vs route vs composant, useClass/useValue/useFactory/useExisting, et les modificateurs optional/self/skipSelf.Dependency Injection
  • 06InjectionToken et provideX()Configuration typée, fonctions provideFeature(), makeEnvironmentProviders et initializers.Dependency Injection
  • 06injectAsync() — services en Lazy LoadingChargez un service lourd uniquement quand vous en avez besoin, avec prefetch à l’idle.Dependency Injection
  • 07Structure des dossierscore / shared / features, ce que contient chacun, et à quoi ressemble l’intérieur d’une feature.Architecture d’application
  • 07Shared vs featureQuand déplacer un composant dans shared et (surtout) quand NE PAS le faire. Une checklist concrète.Architecture d’application
  • 07Interfaces et modèlesInterface en ligne ou fichier séparé ? DTO vs modèle de domaine, type vs interface, où les ranger.Architecture d’application
  • 07State Management avec les SignalsStores simples à base de Signals, facades, état local vs global, et quand NgRx devient nécessaire.Architecture d’application
  • 07Guide de style et nommageLes conventions officielles actuelles : noms de fichiers sans suffixes, protected, readonly, ordre des membres.Architecture d’application
  • 07Barrels, alias et frontièresindex.ts, alias de chemins, API publique d’une feature et règles de dépendances vérifiables automatiquement.Architecture d’application
  • 07Erreurs : @boundary et ErrorHandlerLe nouveau bloc @boundary de la v22.2, l’ErrorHandler global, les erreurs HTTP et les erreurs de resource.Architecture d’application
  • 08Routing moderne et Lazy LoadingloadComponent, routes enfants, paramètres comme inputs et héritage des paramètres (le nouveau comportement par défaut de la v22).Routing
  • 08Guards et resolverscanActivate, canMatch, canDeactivate et resolve sous forme de fonctions, avec redirections via UrlTree / RedirectCommand.Routing
  • 09Signal Forms — les basesDes formulaires bâtis sur les Signals : form(), [formField], validation par schéma. Stable depuis la v22.Formulaires
  • 09Signal Forms — avancéValidation personnalisée et inter-champs, async/HTTP avec debounce, listes dynamiques, désactivé/masqué, schémas réutilisables.Formulaires
  • 09Reactive Forms typésFormGroup typé, nonNullable, FormArray — et leur cohabitation avec les Signal Forms.Formulaires
  • 10HttpClient, interceptors et couche d’APIHttpClient sans configuration (v21), Fetch par défaut (v22), interceptors fonctionnels et une couche d’API avec mapping des DTO.HTTP et données
  • 11Performance — une checklistCe qui compte vraiment : OnPush + Signals, track, @defer, routes en Lazy Loading, images, bundles et Hydration.Qualité et performance
  • 11Tests avec VitestVitest est le runner par défaut depuis la v21. TestBed, composants avec Signals, services, HTTP et harnesses.Qualité et performance
  • 11DevTools : regarder dans votre applicationChrome DevTools et Angular DevTools pas à pas : ce que montre chaque panneau, avec des exercices qui fonctionnent sur ce site.Qualité et performance
  • 11Angular AriaDes composants headless et accessibles que vous stylez comme vous voulez : tabs, accordion, menu, listbox...Qualité et performance
  • 12SSR, Prerendering et modes de renduQuand rendre sur le serveur, quand au build et quand uniquement dans le navigateur : RenderMode par route, app.routes.server.ts et les coûts réels.SSR et Hydration
  • 12Hydration : event replay et incrémentaleComment le navigateur reprend le HTML du serveur sans le re-rendre : Hydration complète, event replay, @defer (hydrate on …) et erreurs de mismatch.SSR et Hydration
  • 12Code compatible serveurwindow n’existe pas sur le serveur : PLATFORM_ID, afterNextRender, DOCUMENT, TransferState, le cache HTTP et PendingTasks.SSR et Hydration
  • 13Micro frontendsQuand découper une application en plusieurs déploiements vaut le coup, et quand c’est juste de la complexité : Native Federation, Module Federation, iframes, Web Components.Architecture à grande échelle
  • 13Web Components avec Angular ElementscreateCustomElement : un composant Angular utilisé comme balise HTML n’importe où, plus la communication entre applications via des événements et BroadcastChannel.Architecture à grande échelle
  • 13Monorepo, bibliothèques et frontièresUn workspace avec plusieurs applications et bibliothèques : ng generate library, Nx, points d’entrée secondaires, publication et règles de dépendances.Architecture à grande échelle
  • 13Architecture hexagonale (ports et adapters)Un domaine sans Angular, des ports sous forme de classes abstraites et des adapters interchangeables : HTTP, localStorage ou en mémoire, sans toucher à l’UI.Architecture à grande échelle
  • 14Les Signals sous le capotLe graphe réactif : producteurs et consommateurs, push-pull, pourquoi computed est lazy et sans glitch, le problème du diamant et quand les effects s’exécutent.Réactivité avancée
  • 14RxJS avancé : opérateurs d’ordre supérieurswitchMap, mergeMap, concatMap et exhaustMap sur un diagramme interactif, plus retry avec backoff, shareReplay et comment éviter les fuites.Réactivité avancée
  • 14NgRx SignalStoreState Management à grande échelle sur les Signals : withState, withComputed, withMethods, rxMethod, entités et hooks — et quand un store simple suffit.Réactivité avancée
  • 14Machines à états avec les signalsFini les états impossibles : une machine typée sur des signals, avec transitions, gardes et un diagramme d’états en direct.Réactivité avancée
  • 15WebSockets : un temps réel qui résiste au réseauUn socket typé sous forme de signals : reconnexion avec backoff et jitter, heartbeat, file d’attente hors ligne et sécurité SSR.Temps réel et hors ligne
  • 15Mises à jour optimistes et rollbackUne UI instantanée qui reste honnête : snapshot et rollback, réponses dans le désordre, clés d’idempotence.Temps réel et hors ligne
  • 15Offline-first : Service Worker et cacheLe Service Worker d’Angular : stratégies de cache, annonce des nouvelles versions et file d’attente pour les modifications faites hors ligne.Temps réel et hors ligne
  • 16Web WorkersDes calculs lourds sans bloquer l’UI : un vrai worker dans la page, l’échange de messages et quand ça n’en vaut pas la peine.UI avancée et performance
  • 16Listes géantes : virtual scroll100 000 lignes sans latence : le virtual scroll du CDK, itemSize, trackBy et les alternatives (pagination, scroll infini).UI avancée et performance
  • 16Animations modernes et View Transitionsanimate.enter et animate.leave à la place de @angular/animations (déprécié), transitions CSS et View Transitions à la navigation.UI avancée et performance
  • 16Fuites mémoire : les trouver et les corrigerAbonnements, timers et listeners qui survivent à leur composant — comment les repérer dans les DevTools et les fermer.UI avancée et performance
  • 17Sécurité : XSS, sanitisation et CSPCe qu’Angular fait automatiquement contre le XSS, quand bypassSecurityTrust devient dangereux, plus la CSP avec nonce, Trusted Types et XSRF.Sécurité et internationalisation
  • 17Authentification : tokens et refreshUn interceptor qui ajoute le token, le renouvelle une seule fois sur une 401 et rejoue les requêtes en attente — plus où conserver le token.Sécurité et internationalisation
  • 17OAuth 2.1 et OpenID Connect avec PKCELe flux authorization code avec PKCE, pas à pas : verifier et challenge, state et nonce, l’ID token, et pourquoi un BFF est plus sûr.Sécurité et internationalisation
  • 17Internationalisation (i18n)$localize, l’attribut i18n, ICU plural/select, un build par langue vs des traductions à l’exécution, et le formatage selon la locale.Sécurité et internationalisation