AngularAtlaséd. 22.2

Chap. 05Conception des composants27 / 75

Smart vs Dumb

Container vs présentation : qui détient l’état, qui se contente d’afficher, et comment bien les séparer.

architecture ~0 min de lecture Documentation officielle

Séparer les composants en smart (container) et dumb (de présentation, « UI ») est la règle d’architecture la plus utile pour les composants. Elle répond à la question : qui a le droit de savoir d’où viennent les données ? La réponse : le moins de composants possible.

Smart / containerDumb / de présentation
RôleOrchestration : récupère les données, gère les actionsAffichage : montre les données, émet des intentions
Injectestores, services d’API, Routerrien de métier (uniquement de l’UI : ElementRef, DestroyRef…)
Communicationstore / servicesuniquement input(), output(), model()
Étatétat métier (ou le délègue à un store)uniquement l’état d’UI local (survol, déplié)
Réutilisationrare — liée à un seul cas d’usagefréquente — partout où vous avez les mêmes données
Testsavec des mocks / un faux storetrivial : vous fournissez des inputs, vous vérifiez les outputs
Où il vitfeatures/x/pagesfeatures/x/ui ou shared/ui

Un exemple complet : un catalogue de produits

Une page smart (CatalogPage) avec un store de feature (CatalogStore) et trois composants dumb : les filtres, la carte produit et le résumé du panier. Les données viennent du backend simulé via httpResource.

LiveCatalogue : 1 smart + 3 dumb + 1 store
Laptop Pro 14
Ordinateur portable★ 4.7
7 499 RON
Laptop Air 13
Ordinateur portable★ 4.4
4 999 RON
Smartphone X
Téléphone★ 4.6
3 999 RON
Smartphone Mini
Téléphone★ 4.1
2 499 RON
Casque de studio
Audio★ 4.8
1 299 RON
Enceinte portable
Audio★ 4
449 RON
Mouse Ergo
Accessoire★ 4.5
349 RON
Clavier mécanique
Accessoire★ 4.9
699 RON
Hub USB-C
Accessoire★ 3.9
229 RON
Monitor 27"
Accessoire★ 4.6
1 899 RON
Panier (0)0 RON
Le panier est vide.
Contour orange = smart, bleu = dumb. Seul CatalogPage injecte quelque chose ; les autres reçoivent tout par des inputs.
// SMART (container) : il sait D’OÙ viennent les données et CE QUI se passe lors d’une action.
@Component({
  selector: 'app-catalog-page',
  imports: [ProductFilters, ProductCard, CartSummary],
  providers: [CatalogStore], // le store vit aussi longtemps que la page
  template: `
    <app-product-filters [categories]="categories" [(query)]="store.query" [(category)]="store.category" />

    @for (p of store.products.value(); track p.id) {
      <app-product-card [product]="p" (addToCart)="store.add($event)" />
    }

    <app-cart-summary
      [lines]="store.cart()" [count]="store.cartCount()" [total]="store.cartTotal()"
      (remove)="store.remove($event)" />
  `,
})
export class CatalogPage {
  protected readonly store = inject(CatalogStore);
  protected readonly categories: ProductCategory[] = ['laptop', 'phone', 'audio', 'accessory'];
}

Où vivent les fichiers

features/catalog/
├── catalog.routes.ts
├── pages/
│   └── catalog-page.ts          ← SMART (routée)
├── data-access/
│   ├── catalog-store.ts          ← état + données
│   └── catalog-api.ts
├── ui/                           ← DUMB, propre à la feature
│   ├── product-card.ts
│   ├── product-filters.ts
│   └── cart-summary.ts
└── models/
    └── product.ts                ← Product + toProduct(dto)

shared/ui/                        ← DUMB, générique (sans domaine)
├── button.ts
├── rating.ts
└── data-table.ts

Anti-pattern : le composant « dumb » qui est en réalité smart

// ✗ Un composant « dumb » qui est en réalité smart déguisé
@Component({ selector: 'app-product-card', /* ... */ })
export class ProductCard {
  private readonly cart = inject(CartStore);   // ← dépendance à l’état global
  private readonly http = inject(HttpClient);  // ← fait des requêtes
  private readonly router = inject(Router);    // ← décide de la navigation

  readonly productId = input.required<number>();
  readonly product = httpResource<Product>(() => `/api/products/${this.productId()}`);

  add() {
    this.cart.add(this.product.value()!);
    this.router.navigate(['/cart']);
  }
}
// Conséquences : vous ne pouvez pas le réutiliser sur une autre page (par ex. dans les « recommandations » ou dans l’admin),
// vous ne pouvez pas le tester sans mocks pour HttpClient, Router et CartStore,
// et une liste de 50 cartes fait 50 requêtes.

Ce qu’un composant dumb a le droit de faire

// ✓ État d’UI local dans un composant dumb — parfaitement OK
export class Accordion {
  readonly items = input.required<Item[]>();
  protected readonly expanded = signal<number | null>(null); // concerne uniquement l’affichage
}

// ✓ Injections « UI » dans un composant dumb — OK
inject(ElementRef); inject(DestroyRef); inject(LOCALE_ID); inject(Dialog /* CDK */);

Règles pratiques

  1. Une page routée = un container smart. Il relie l’URL, le store et l’UI.
  2. Les composants dumb n’injectent ni stores ni services de données. Si vous en ressentez le besoin, remontez la logique d’un niveau.
  3. Les outputs expriment des intentions, pas des implémentations : (addToCart), pas (callCartServiceAndNavigate).
  4. Tout n’a pas à être dumb. Un widget complexe dans une page (par ex. les « commentaires ») peut être un mini container smart avec son propre store — mieux que de passer 15 inputs à travers 4 niveaux.
  5. Le prop drilling sur 2 à 3 niveaux est le signe qu’il vous faut un container intermédiaire ou un store de feature.

L’état d’un composant smart vit généralement dans un store : State Management avec les Signals. Comment les deux communiquent : input() et output().

Quand OUI, quand NON

Rendre le composant dumb
  • Il affiche des données reçues (carte, ligne de tableau, avatar, badge).
  • C’est un contrôle (filtre, notation, bascule) — l’état passe par model().
  • Vous voulez le réutiliser sur une autre page ou dans shared/ui.
  • Vous voulez le tester facilement ou l’afficher dans Storybook.
Le laisser smart
  • C’est une page routée.
  • C’est un widget autonome avec ses propres données (chat, notifications) utilisé « tel quel » sur plusieurs pages.
  • Le rendre dumb demanderait plus de 10 inputs/outputs transmis à travers plusieurs niveaux.

Chap. 05 · 0 sur 6 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. Smart vs Dumb
  2. Composants génériques <T>
  3. Composants dynamiques
  4. Directives et composition d’hôte
  5. Contrôles de formulaire personnalisés
  6. Change Detection
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