AngularAtlaséd. 22.2

Chap. 01Départ03 / 75

Décisions rapides

« Où mettre ça ? », « Signal ou Observable ? », « Shared ou feature ? » — des réponses courtes aux questions de tous les jours.

architecture ~0 min de lecture

Les questions que vous vous posez dix fois par jour, avec une réponse courte et un lien vers la page qui l’explique en détail. Cherchez par mot ou filtrez par catégorie.

Les principes derrière chaque réponse

  1. Au plus près de l’usage

    Les types, composants et états restent à côté du code qui les utilise ; vous ne les remontez que lorsqu’un nouveau consommateur apparaît.

  2. Une seule source de vérité

    Ce qui peut être calculé est dérivé (computed), pas stocké.

  3. L’outil le plus simple qui résout le problème

    @switch avant les composants dynamiques, un service à base de signals avant NgRx, la duplication avant la mauvaise abstraction.

  4. Immutabilité

    De nouvelles références pour de nouvelles données ; les signals et OnPush en dépendent.

Questions et réponses

41 questions sur 41

01

Composants

7

Mon composant est-il smart ou dumb ?

S’il injecte des stores / des API / le Router → smart (page ou conteneur). S’il reçoit tout par des inputs et émet des outputs → dumb. Les pages routées sont smart ; gardez dumb le plus possible du reste.

Smart vs Dumb

Quand le rendre générique (<T>) ?

Quand vous avez déjà 2 ou 3 usages avec LE MÊME comportement sur des données différentes (tableau, select, liste) et que l’API ne contient aucun terme métier. Sinon, il reste spécifique.

Composants génériques <T>

Quand le rendre dynamique ?

Seulement quand vous ne savez pas à la compilation quel composant apparaît (config, CMS, plugins, tableau de bord). Pour 2 à 5 variantes connues, utilisez @switch.

Composants dynamiques

input + output ou model() ?

model() pour les valeurs de « contrôle » (toggle, slider, onglet actif). input + output quand le parent doit décider/valider, ou que l’événement a un sens (enregistrer, supprimer).

model() — binding bidirectionnel

ng-content ou ng-template ?

ng-content pour du contenu statique affiché une fois. ng-template quand le contenu doit être créé en lazy, répété, ou recevoir des données (contexte).

Projection de contenu

Composant ou directive ?

Directive si vous ajoutez seulement un comportement à un élément existant (tooltip, autofocus). Composant si vous avez votre propre balisage ou vos propres styles.

Directives et composition d’hôte

Projection ou inputs pour le contenu ?

Inputs quand le composant contrôle l’apparence (cohérence). Projection quand le parent a besoin d’un balisage libre (dialogues, cartes).

Projection de contenu
02

Architecture

7

Déplacer le composant dans shared ?

Seulement s’il est utilisé MAINTENANT dans 2 fonctionnalités ou plus, n’a aucun terme métier, n’injecte pas de données et se comporte partout pareil. Sinon, il vit dans features/x/ui.

Shared vs feature

Interface en ligne ou fichier séparé ?

Utilisée par un seul fichier → en ligne. Type d’input/output → exporté depuis le fichier du composant. Utilisée par plusieurs fichiers d’une fonctionnalité → features/x/models. Entre fonctionnalités → l’API publique du propriétaire.

Interfaces et modèles

Faut-il un DTO distinct du modèle ?

Oui, si l’API suit d’autres conventions, si vous ne la maîtrisez pas, ou si l’interface a des champs dérivés. Non, pour un CRUD simple aux types déjà propres.

Interfaces et modèles

Que met-on dans core ?

Ce qui est utilisé une seule fois au niveau de l’application ou comme infrastructure : auth, layout (shell), ErrorHandler, interceptors, services transversaux.

Structure des dossiers

Peut-on importer une fonctionnalité depuis une autre ?

Idéalement non. Communiquez via l’URL, un store dans core, ou shared. Si c’est inévitable : uniquement via l’API publique de l’autre fonctionnalité (index.ts).

Barrels, alias et frontières

Des barrels (index.ts) partout ?

Non. Seulement à la frontière d’une fonctionnalité/bibliothèque, comme API publique. À l’intérieur, importez directement les fichiers.

Barrels, alias et frontières

Enum ou union de strings ?

Union + objet as const. Plus simple, compatible Tree-shaking, facile à parcourir dans les templates.

Interfaces et modèles
03

État & données

7

signal, computed ou linkedSignal ?

signal = état indépendant. computed = dérivé, en lecture seule. linkedSignal = dérivé, mais modifiable (une sélection qui se réinitialise, un brouillon d’un input).

linkedSignal() — état dérivé modifiable

Quand utiliser effect() ?

Uniquement pour des effets vers l’extérieur : localStorage, logs, bibliothèques impératives, le DOM. Jamais pour définir un autre signal (→ computed / linkedSignal).

effect() — quand OUI, quand NON

Signal ou Observable ?

Signal pour l’état affiché. Observable pour les flux d’événements dans le temps (websocket, drag, opérateurs complexes). Le pont : toSignal / toObservable.

Signals ↔ RxJS

Comment charger des données depuis le serveur ?

Lectures réactives → httpResource (ou resource / rxResource). Écritures (POST/PUT/DELETE) → HttpClient, puis mise à jour/rechargement de la resource.

resource, rxResource, httpResource

Où conserver l’état ?

Le plus bas possible : composant → store de fonctionnalité (providers sur la route/page) → global (@Service en root). Filtres partageables → l’URL.

State Management avec les Signals

Ai-je besoin de NgRx ?

En général non : un service avec des signals suffit. NgRx SignalStore si vous voulez des conventions/plugins ; NgRx Store si vous avez besoin d’un journal d’actions et du time-travel.

State Management avec les Signals

Debounce sur un signal ?

debounced(sig, 300) (v22, expérimental). Dans Signal Forms : la règle debounce() ou l’option debounce de validateHttp.

debounced() — signals différés
04

Template

5

Méthode, pipe ou computed dans le template ?

computed pour les calculs propres au composant ; une pipe pure pour le formatage réutilisable ; une méthode seulement pour les choses triviales (elle s’exécute à chaque rendu).

Pipes : quand et comment

Que tracker dans @for ?

Un id stable (track item.id). $index seulement pour les listes statiques. L’identité (track item) seulement si les objets ne sont pas recréés.

Control Flow : @if, @for, @switch
05

DI

5

@Service() ou @Injectable() ?

Nouveau code en v22 : @Service() (singleton auto-provided, inject() uniquement). @Injectable si vous utilisez la DI par constructeur ou devez prendre en charge d’anciennes versions.

inject() et @Service()

Où fournir le service ?

Root si l’état doit survivre à la navigation. Route/page pour l’état d’une fonctionnalité. Composant pour une instance par composant (assistant, éditeur).

Providers et hiérarchie des injecteurs

Classe ou InjectionToken ?

Classe quand vous avez de la logique/des méthodes. InjectionToken pour les valeurs : config, URLs, fonctions, plugins (multi).

InjectionToken et provideX()

Une interface pour le service (IUserService) ?

Non. Si vous avez besoin de plusieurs implémentations ou de mocks : une classe abstraite comme token, avec @Service({ factory }) pour l’implémentation par défaut.

inject() et @Service()
06

Formulaires & routing

6

Signal Forms ou Reactive Forms ?

Nouveaux formulaires en v22 → Signal Forms. Les Reactive existants restent ; vous migrez progressivement avec SignalFormControl / compatForm.

Signal Forms — les bases

Contrôle personnalisé : FormValueControl ou CVA ?

FormValueControl pour Signal Forms (un model() + des inputs facultatifs). ControlValueAccessor pour Reactive / Template-driven.

Contrôles de formulaire personnalisés

Resolver ou httpResource ?

Resolver pour des données petites et indispensables. httpResource + skeleton pour les listes et tableaux de bord (navigation instantanée).

Guards et resolvers

canMatch ou canActivate ?

canMatch pour les zones restreintes (il ne télécharge pas le chunk). canActivate pour les vérifications à l’entrée d’une route qui existe pour tout le monde.

Guards et resolvers

Route séparée ou état dans la page ?

Une route si l’écran a besoin de son propre lien (partageable, bouton retour). État local pour les dialogues, dropdowns, étapes éphémères.

Routing moderne et Lazy Loading

Comment lire les paramètres de route ?

withComponentInputBinding() + input() dans le composant routé. Pas d’ActivatedRoute ni de subscribe.

Routing moderne et Lazy Loading
07

Qualité

4

Pourquoi l’interface ne se met-elle pas à jour ?

Presque certainement : un champ simple a changé de façon asynchrone (setTimeout, subscribe) dans une application zoneless/OnPush, ou un objet a été muté. Passez aux signals et aux mises à jour immuables.

Change Detection

Où gérer les erreurs ?

Prévisibles → localement (resource.error()). Transversales (401/500) → interceptor. Échec de rendu d’une zone → @boundary. Le reste → ErrorHandler global.

Erreurs : @boundary et ErrorHandler

Que tester, et comment ?

Stores et mappers : tests unitaires, sans DOM. Composants dumb : createComponent + bindings. Pages : faux store + HttpTestingController. Parcours : e2e.

Tests avec Vitest

Mes propres composants sont-ils accessibles ?

Construisez-les sur Angular Aria (headless) : clavier, focus et ARIA corrects ; le style est à vous.

Angular Aria

Chap. 01 · 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. Nouveautés d’Angular 21 & 22
  2. Votre première application, pas à pas
  3. Décisions rapides
  4. Questions d’entretien Angular
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