Front-end12 min de lecture
Composants smart et dumb en Angular et React, en 2026
Ce qui sépare un composant smart d'un dumb, le même exemple en Angular 22 et React 19, ce que l'auteur du modèle a revu et quand la séparation vaut encore.

« Smart et dumb components » fait partie de ces sujets qui reviennent en entretien, en code review et dans chaque discussion d'architecture front. Parfois sous un autre nom : container et presentational. L'idée est simple, mais beaucoup de choses ont changé depuis qu'elle est devenue célèbre, et si vous l'avez apprise en 2016, vous l'appliquez probablement encore à l'ancienne.
Cet article explique la séparation, montre le même exemple en Angular et en React avec la façon de faire actuelle de chacun, et raconte un point que peu de gens connaissent : l'auteur du texte qui a popularisé le modèle en React a écrit, des années plus tard, qu'il ne recommande plus de découper les composants ainsi.
Une précision honnête : les exemples ont été compilés et testés avec Angular 22.3 et React 19.3. Chacun a un test qui charge les commandes, filtre et en sélectionne une, et les deux passent.
TL;DR#
- Smart sait d'où viennent les données et décide quoi en faire. Dumb reçoit tout par
inputou props et se contente de signaler, par un événement, que quelque chose s'est passé. - En Angular, la séparation s'intègre très bien :
input(),output()etmodel()dans le dumb,httpResourceetcomputeddans le smart. Depuis la version 22,OnPushest la valeur par défaut. - En React, la partie « smart » est aujourd'hui le plus souvent un hook, pas un composant container. Dan Abramov lui-même a revu son article en 2019 pour le dire.
- Avec les Server Components, la séparation revient sous une autre forme : le composant serveur récupère les données, le composant client gère l'interaction.
- Ne découpez pas par dogme. Séparez quand la logique de données gêne la lecture de l'écran ou quand le composant visuel doit être réutilisé.
Ce qu'est chacun#
| Smart (container) | Dumb (presentational) | |
|---|---|---|
| Données | les récupère depuis l'API, le service ou le store | reçoit tout par input ou props |
| Décisions | décide ce qui se passe au clic | signale seulement le clic |
| État | état de l'écran (filtre, sélection, chargement) | au plus un état visuel (ouvert, fermé) |
| Dépendances | services, HTTP, routeur | aucune, à part d'autres composants visuels |
| Réutilisation | presque nulle, c'est la colle de l'écran | forte, fonctionne sur n'importe quel écran |
| Tests | il faut simuler l'API | il suffit de passer des données et de vérifier le HTML |
Remarquez la ligne de l'état : un composant dumb peut avoir un état, tant qu'il s'agit d'un état d'interface, comme un menu ouvert ou fermé. Ce qu'il ne peut pas faire, c'est savoir d'où viennent les données ni quoi en faire.
Pourquoi séparer#
- Le composant visuel devient réutilisable. Une carte de commande qui reçoit seulement un
orderfonctionne dans la liste, dans le détail, dans l'aperçu d'un e-mail. - Les tests coûtent peu. Pour tester le dumb, vous passez des données et vérifiez le HTML. Pas d'API à simuler, pas de faux service.
- Changer la source des données ne touche pas l'écran. Si l'API change, ou si les données viennent d'un cache, seul le smart change.
- On voit clairement qui décide. Les données descendent par
inputou props, les événements remontent. Quand quelque chose casse, vous savez où chercher.
L'exemple : une liste de commandes#
Les deux exemples construisent le même écran : une liste de commandes avec un filtre par statut et la sélection d'une commande.
OrdersPage(smart) : récupère les commandes, garde le filtre et la commande sélectionnée.StatusFilter(dumb) : affiche les boutons de statut et signale quand il change.OrderList(dumb) : dessine la liste ou le message de liste vide.OrderCard(dumb) : dessine une commande et signale quand on clique sur « Details ».
Le modèle est le même dans les deux :
export type OrderStatus = 'pending' | 'paid' | 'shipped';
export interface Order {
id: string;
customer: string;
total: number;
status: OrderStatus;
}En Angular#
La carte (dumb)#
import { CurrencyPipe } from '@angular/common';
import { Component, input, output } from '@angular/core';
import { Order } from './order';
@Component({
selector: 'app-order-card',
imports: [CurrencyPipe],
template: `
<article class="card" [class.selected]="selected()">
<h3>{{ order().customer }}</h3>
<p>{{ order().total | currency: 'BRL' }} · {{ order().status }}</p>
<button type="button" (click)="orderSelected.emit(order().id)">Details</button>
</article>
`,
})
export class OrderCard {
readonly order = input.required<Order>();
readonly selected = input(false);
readonly orderSelected = output<string>();
}input.required<Order>()oblige celui qui utilise le composant à passer la commande. En cas d'oubli, l'erreur apparaît au build, pas en production.input(false)est un input optionnel avec une valeur par défaut.output<string>()est l'événement. Le composant émet seulement l'id et ne sait pas ce qui se passera ensuite.readonlysur les inputs et outputs est une recommandation du guide de style d'Angular : il empêche d'écraser ce qu'Angular renseigne.
Un détail de nommage : l'événement s'appelle orderSelected, pas select. Le guide d'Angular demande d'éviter les noms qui entrent en collision avec les événements du DOM, et select en fait partie.
La liste et le filtre (dumb)#
import { Component, input, output } from '@angular/core';
import { Order } from './order';
import { OrderCard } from './order-card';
@Component({
selector: 'app-order-list',
imports: [OrderCard],
template: `
@for (order of orders(); track order.id) {
<app-order-card
[order]="order"
[selected]="order.id === selectedId()"
(orderSelected)="orderSelected.emit($event)"
/>
} @empty {
<p class="empty">No orders here yet.</p>
}
`,
})
export class OrderList {
readonly orders = input.required<Order[]>();
readonly selectedId = input<string | null>(null);
readonly orderSelected = output<string>();
}La liste ne décide rien : elle reçoit les commandes, marque celle qui est sélectionnée et fait remonter l'événement. Le @empty gère la liste vide sans @if supplémentaire.
import { Component, model } from '@angular/core';
import { OrderStatus } from './order';
export type StatusFilterValue = OrderStatus | 'all';
@Component({
selector: 'app-status-filter',
template: `
@for (option of options; track option) {
<button type="button" [class.active]="option === status()" (click)="status.set(option)">
{{ option }}
</button>
}
`,
})
export class StatusFilter {
readonly status = model<StatusFilterValue>('all');
protected readonly options: StatusFilterValue[] = ['all', 'pending', 'paid', 'shipped'];
}Le filtre utilise model(), un input que le composant peut aussi modifier lui-même. De l'extérieur, on le relie dans les deux sens avec [(status)]. C'est la façon d'Angular d'écrire la paire « valeur et événement de changement » en une seule ligne.
La page (smart)#
import { httpResource } from '@angular/common/http';
import { Component, computed, signal } from '@angular/core';
import { Order } from './order';
import { OrderList } from './order-list';
import { StatusFilter, StatusFilterValue } from './status-filter';
@Component({
selector: 'app-orders-page',
imports: [OrderList, StatusFilter],
template: `
<h2>Orders</h2>
<app-status-filter [(status)]="status" />
@if (orders.isLoading()) {
<p>Loading orders...</p>
} @else if (orders.error()) {
<p>Could not load the orders.</p>
} @else {
<app-order-list
[orders]="visibleOrders()"
[selectedId]="selectedId()"
(orderSelected)="selectedId.set($event)"
/>
}
`,
})
export class OrdersPage {
protected readonly status = signal<StatusFilterValue>('all');
protected readonly selectedId = signal<string | null>(null);
protected readonly orders = httpResource<Order[]>(() => '/api/orders', { defaultValue: [] });
protected readonly visibleOrders = computed(() => {
const status = this.status();
const orders = this.orders.value();
return status === 'all' ? orders : orders.filter((order) => order.status === status);
});
}httpResourcefait l'appel HTTP et exposevalue(),isLoading()eterror()sous forme de signals. C'est une API stable depuis Angular 22. Il fautprovideHttpClient()dans la configuration de l'application.computeddérive la liste filtrée du filtre et des commandes. Le filtre change, la liste se recalcule toute seule.protectedsur les membres utilisés seulement par le template est une autre recommandation du guide de style : ils ne font pas partie de l'API publique du composant.
Et ce qui est resté dehors compte aussi : aucun composant dumb n'importe HttpClient, un service ou le routeur. Si demain les commandes arrivent par WebSocket, seul OrdersPage change.
Et OnPush ?#
Pendant des années, le conseil était « mettez ChangeDetectionStrategy.OnPush sur les composants dumb », pour qu'Angular ne les vérifie que lorsque leurs inputs changent. Dans Angular 22, OnPush est devenu la valeur par défaut, et l'ancienne stratégie, désormais appelée Eager, est celle qu'il faut demander. C'est pour ça que les exemples ci-dessus ne déclarent rien. Dans les projets sur des versions plus anciennes, le conseil reste valable.
Quand la logique est partagée#
Si deux écrans ont besoin des mêmes commandes, sortez le httpResource et l'état du composant pour les placer dans un service avec @Injectable({ providedIn: 'root' }). La page reste smart, mais légère : elle fait seulement inject(OrdersStore) et relie les données aux composants dumb.
En React#
Les composants visuels (dumb)#
import type { Order } from './order';
interface OrderCardProps {
order: Order;
selected?: boolean;
onSelect: (id: string) => void;
}
const brl = new Intl.NumberFormat('pt-BR', { style: 'currency', currency: 'BRL' });
export function OrderCard({ order, selected = false, onSelect }: OrderCardProps) {
return (
<article className={selected ? 'card selected' : 'card'}>
<h3>{order.customer}</h3>
<p>{brl.format(order.total)} · {order.status}</p>
<button type="button" onClick={() => onSelect(order.id)}>Details</button>
</article>
);
}import type { Order } from './order';
import { OrderCard } from './OrderCard';
interface OrderListProps {
orders: Order[];
selectedId: string | null;
onSelect: (id: string) => void;
}
export function OrderList({ orders, selectedId, onSelect }: OrderListProps) {
if (orders.length === 0) return <p className="empty">No orders here yet.</p>;
return orders.map((order) => (
<OrderCard key={order.id} order={order} selected={order.id === selectedId} onSelect={onSelect} />
));
}import type { OrderStatus } from './order';
export type StatusFilterValue = OrderStatus | 'all';
const OPTIONS: StatusFilterValue[] = ['all', 'pending', 'paid', 'shipped'];
interface StatusFilterProps {
value: StatusFilterValue;
onChange: (value: StatusFilterValue) => void;
}
export function StatusFilter({ value, onChange }: StatusFilterProps) {
return OPTIONS.map((option) => (
<button key={option} type="button" className={option === value ? 'active' : undefined} onClick={() => onChange(option)}>
{option}
</button>
));
}En React, le rôle de l'output revient à une fonction passée en props. La convention est de la nommer on + action (onSelect, onChange). Le rôle du model() revient à la paire value et onChange.
La page (smart)#
import { useEffect, useState } from 'react';
import type { Order } from './order';
type LoadState = 'loading' | 'ready' | 'error';
export function useOrders() {
const [orders, setOrders] = useState<Order[]>([]);
const [state, setState] = useState<LoadState>('loading');
useEffect(() => {
const controller = new AbortController();
fetch('/api/orders', { signal: controller.signal })
.then((response) => {
if (!response.ok) throw new Error(`HTTP ${response.status}`);
return response.json() as Promise<Order[]>;
})
.then((data) => {
setOrders(data);
setState('ready');
})
.catch(() => {
if (!controller.signal.aborted) setState('error');
});
return () => controller.abort();
}, []);
return { orders, state };
}import { useState } from 'react';
import { OrderList } from './OrderList';
import { StatusFilter, type StatusFilterValue } from './StatusFilter';
import { useOrders } from './useOrders';
export function OrdersPage() {
const { orders, state } = useOrders();
const [status, setStatus] = useState<StatusFilterValue>('all');
const [selectedId, setSelectedId] = useState<string | null>(null);
const visibleOrders = status === 'all' ? orders : orders.filter((order) => order.status === status);
return (
<>
<h2>Orders</h2>
<StatusFilter value={status} onChange={setStatus} />
{state === 'loading' && <p>Loading orders...</p>}
{state === 'error' && <p>Could not load the orders.</p>}
{state === 'ready' && <OrderList orders={visibleOrders} selectedId={selectedId} onSelect={setSelectedId} />}
</>
);
}Une remarque sur useOrders : récupérer des données avec useEffect fonctionne et garde l'exemple court, mais la documentation de React recommande, dans une vraie application, d'utiliser la récupération de données du framework ou une bibliothèque avec cache. La séparation smart et dumb ne change pas pour autant : seul le contenu du hook change.
Ce que l'auteur du modèle a revu#
Le texte qui a popularisé la séparation en React s'appelle « Presentational and Container Components », de Dan Abramov, publié en 2015. En 2019, il a ajouté une note en haut : « I don't suggest splitting your components like this anymore ». Son explication, en résumé : ce qu'il appréciait le plus dans la séparation, c'était d'isoler la logique avec état du reste du composant, et les hooks le font sans obliger à créer un composant de plus. Il raconte aussi avoir vu le modèle imposé sans nécessité, presque comme une règle religieuse.
En pratique, cela change la conception :
- La partie smart est devenue le hook.
useOrdersregroupe la récupération et l'état de chargement. Tout composant qui a besoin des commandes appelle le hook, sans container au milieu. - Les composants dumb restent excellents.
OrderCardetOrderListreçoivent toujours tout par props, et c'est ce qui les rend faciles à tester et à réutiliser. - Le container est devenu optionnel.
OrdersPageexiste encore parce que c'est l'écran, pas parce que le modèle l'exige.
Server Components : la séparation est de retour#
Avec les React Server Components (dans un framework qui les prend en charge, comme l'App Router de Next.js), la séparation réapparaît, cette fois selon l'endroit où le code s'exécute :
import type { Order } from '../order';
import { OrdersView } from './orders-view';
async function getOrders(): Promise<Order[]> {
const response = await fetch('https://api.example.com/orders', { cache: 'no-store' });
if (!response.ok) throw new Error(`HTTP ${response.status}`);
return response.json();
}
// Server Component: runs on the server, fetches the data and never ships this code to the browser.
export default async function OrdersPage() {
const orders = await getOrders();
return <OrdersView orders={orders} />;
}'use client';
import { useState } from 'react';
import type { Order } from '../order';
import { OrderList } from '../OrderList';
import { StatusFilter, type StatusFilterValue } from '../StatusFilter';
// Client Component: receives the data as props and handles the interaction.
export function OrdersView({ orders }: { orders: Order[] }) {
const [status, setStatus] = useState<StatusFilterValue>('all');
const [selectedId, setSelectedId] = useState<string | null>(null);
const visibleOrders = status === 'all' ? orders : orders.filter((order) => order.status === status);
return (
<>
<StatusFilter value={status} onChange={setStatus} />
<OrderList orders={visibleOrders} selectedId={selectedId} onSelect={setSelectedId} />
</>
);
}Le composant serveur est le smart : il récupère les données près de la base, et son code n'arrive même pas dans le navigateur. Le composant avec 'use client' gère le filtre et la sélection, et les dumb restent les mêmes qu'avant.
Angular et React côte à côte#
| Idée | Angular 22 | React 19 |
|---|---|---|
| Recevoir des données | input() / input.required() | props |
| Prévenir le parent | output() + .emit() | fonction en props (onSelect) |
| Valeur dans les deux sens | model() + [(valeur)] | value + onChange |
| Récupérer des données | httpResource ou service avec inject() | hook, récupération du framework ou Server Component |
| Dériver des données | computed() | calcul direct dans le rendu |
| Liste | @for (...; track id) | .map() avec key |
| Liste vide | @empty | if avant le map |
| Éviter les rendus inutiles | OnPush, par défaut depuis la v22 | memo ou le React Compiler |
Erreurs fréquentes#
- Le dumb qui injecte « juste un petit service ». Un seul
inject(HttpClient)ou unfetchdans la carte suffit pour qu'elle ne soit plus réutilisable. S'il lui faut des données, elle les reçoit par input. - Le smart qui devient tout-puissant. Une page de 600 lignes de logique n'a rien amélioré. Déplacez la logique dans un service (Angular) ou un hook (React) et laissez la page se contenter de relier les pièces.
- Du prop drilling sur cinq niveaux. Faire passer la même donnée par quatre composants qui ne l'utilisent pas indique qu'un composant plus bas pourrait être smart, ou que la donnée mérite un service (Angular) ou un contexte (React).
- Croire qu'un dumb ne peut pas avoir d'état. L'état visuel, comme un accordéon ouvert, vit dans le composant lui-même. Ce qui n'y vit pas, ce sont les données métier.
- Des noms d'événements identiques à ceux du DOM.
select,changeetclickembrouillent celui qui lit le template. PréférezorderSelected,statusChange. - Tout découper par principe. Un petit composant qui récupère et affiche trois lignes n'a pas besoin de devenir deux fichiers.
Quand ça vaut le coup#
Ma recommandation :
- Toujours séparer les composants visuels qui apparaissent sur plus d'un écran. Ils doivent tout recevoir par input ou props.
- Presque toujours regrouper la récupération des données et l'état de l'écran au même endroit : la page, un service ou un hook.
- En React, préférez un hook à un composant container. Créez le container seulement quand c'est vraiment l'écran.
- En Angular, la séparation vient presque gratuitement avec les signals. Profitez-en, mais ne créez pas un composant juste pour « respecter le modèle ».
- Ne découpez pas les petits composants utilisés une seule fois. Séparer a aussi un coût de lecture.
Checklist#
- Les composants visuels reçoivent les données seulement par
inputou props. - Les composants visuels préviennent le parent par
outputou une fonctionon..., sans décider de ce qui se passe. - Aucun composant visuel n'importe HTTP, un service de données ou le routeur.
- Récupération des données et état de l'écran au même endroit (page, service ou hook).
- En Angular :
input.requiredpour ce qui est obligatoire,readonlysur les inputs et outputs,protectedsur ce qui ne sert qu'au template. - En React : logique avec état dans des hooks, props
on...pour les événements. - Des noms d'événements qui n'entrent pas en collision avec ceux du DOM.
- Rien de découpé juste par principe.
Références#
- Presentational and Container Components, Dan Abramov (avec la note de 2019)
- Les inputs dans Angular
- Les outputs dans Angular
- Guide de style d'Angular
- httpResource dans Angular
- Réutiliser la logique avec des hooks dans React
- Server Components dans React
- useEffect et la récupération de données dans React
Commentaires
Connectez-vous avec votre compte GitHub pour commenter.
À lire aussi

Front-end9 min de lecture
camelCase, PascalCase, kebab-case et snake_case : quand ?

Front-end11 min de lecture
Signals dans Angular 22 : signal, computed, effect et plus

Front-end11 min de lecture
Storybook : comment démarrer et jusqu'où aller