Front-end12 min de leitura
Smart e dumb components no Angular e no React, em 2026
O que muda entre componente smart e dumb, o mesmo exemplo no Angular 22 e no React 19, o que o próprio criador do padrão revisou e quando a divisão ainda vale.

"Smart e dumb components" é daqueles assuntos que aparecem em entrevista, em code review e em toda discussão sobre arquitetura de front. Às vezes com outro nome: container e presentational. A ideia é simples, mas muita coisa mudou desde que ela ficou famosa, e quem aprendeu em 2016 provavelmente está aplicando do jeito antigo.
Este post explica a divisão, mostra o mesmo exemplo no Angular e no React com o jeito atual de cada um e conta uma parte que pouca gente sabe: o próprio autor do texto que popularizou o padrão no React escreveu, anos depois, que não recomenda mais dividir os componentes assim.
Um aviso honesto: os exemplos foram compilados e testados no Angular 22.3 e no React 19.3. Cada um tem um teste que carrega os pedidos, filtra e seleciona um, e os dois passam.
TL;DR#
- Smart sabe de onde vêm os dados e decide o que fazer com eles. Dumb recebe tudo por
inputou props e só avisa, por evento, que algo aconteceu. - No Angular, a divisão encaixa muito bem:
input(),output()emodel()no dumb,httpResourceecomputedno smart. Desde a versão 22, oOnPushjá é o padrão. - No React, a parte "smart" hoje costuma ser um hook, não um componente container. O próprio Dan Abramov revisou o artigo dele em 2019 dizendo isso.
- Com Server Components, a divisão voltou com outra cara: o componente do servidor busca os dados, o componente do cliente cuida da interação.
- Não divida por dogma. Separe quando a lógica de dados atrapalha a leitura da tela ou quando o componente visual precisa ser reaproveitado.
O que é cada um#
| Smart (container) | Dumb (presentational) | |
|---|---|---|
| Dados | busca na API, no serviço, no store | recebe tudo por input ou props |
| Decisões | decide o que acontece num clique | só avisa que houve o clique |
| Estado | estado da tela (filtro, seleção, carregando) | no máximo estado visual (aberto, fechado) |
| Dependências | serviços, HTTP, roteador | nenhuma, além de outros componentes visuais |
| Reuso | quase nenhum, é a cola da tela | alto, funciona em qualquer tela |
| Teste | precisa simular a API | basta passar dados e conferir o HTML |
Repare no detalhe da linha de estado: componente dumb pode ter estado, desde que seja estado de interface, como um menu aberto ou fechado. O que ele não pode é saber de onde vêm os dados nem o que fazer com eles.
Por que separar#
- O componente visual fica reaproveitável. Um cartão de pedido que só recebe um
orderfunciona na lista, no detalhe, no e-mail de preview. - Teste fica barato. Pra testar o dumb, você passa dados e confere o HTML. Sem simular API, sem serviço falso.
- Trocar a fonte dos dados não mexe na tela. Se a API muda, ou se os dados passam a vir de cache, só o smart muda.
- Fica claro quem manda. Os dados descem por
inputou props, os eventos sobem. Quando algo dá errado, você sabe onde procurar.
O exemplo: uma lista de pedidos#
Os dois exemplos montam a mesma tela: uma lista de pedidos com filtro por status e seleção de um pedido.
OrdersPage(smart): busca os pedidos, guarda o filtro e qual pedido está selecionado.StatusFilter(dumb): mostra os botões de status e avisa quando muda.OrderList(dumb): desenha a lista ou o aviso de vazio.OrderCard(dumb): desenha um pedido e avisa quando clicam em "Details".
O modelo é o mesmo nos dois:
export type OrderStatus = 'pending' | 'paid' | 'shipped';
export interface Order {
id: string;
customer: string;
total: number;
status: OrderStatus;
}No Angular#
O cartão (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>()obriga quem usa o componente a passar o pedido. Se esquecer, o erro aparece no build, não em produção.input(false)é um input opcional com valor padrão.output<string>()é o evento. O componente só emite o id e não sabe o que vai acontecer depois.readonlyem inputs e outputs é recomendação do guia de estilo do Angular: impede que alguém sobrescreva o que o Angular preenche.
Um detalhe de nome: o evento se chama orderSelected, e não select. O guia do Angular pede pra evitar nomes que colidem com eventos do DOM, e select é um deles.
A lista e o filtro (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>();
}A lista não decide nada: recebe os pedidos, marca o selecionado e repassa o evento pra cima. O @empty cuida do estado vazio sem precisar de um @if extra.
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'];
}O filtro usa model(), que é um input que também pode ser alterado pelo próprio componente. Do lado de fora, quem usa liga nos dois sentidos com [(status)]. É o jeito do Angular de fazer o par "valor e evento de mudança" numa linha só.
A página (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);
});
}httpResourcefaz a chamada HTTP e expõevalue(),isLoading()eerror()como signals. Ele é API estável desde o Angular 22. Precisa deprovideHttpClient()na configuração da aplicação.computedderiva a lista filtrada do filtro e dos pedidos. Muda o filtro, a lista se recalcula sozinha.protectednos membros usados só no template é outra recomendação do guia de estilo: eles não fazem parte da API pública do componente.
E o que ficou de fora também importa: nenhum componente dumb importa HttpClient, serviço ou roteador. Se amanhã os pedidos vierem de um WebSocket, só OrdersPage muda.
E o OnPush?#
Durante anos, a dica era "coloque ChangeDetectionStrategy.OnPush nos componentes dumb", pra que o Angular só os verificasse quando os inputs mudassem. No Angular 22, o OnPush passou a ser o padrão, e a estratégia antiga, agora chamada Eager, é a que você precisa pedir. Por isso os exemplos acima não declaram nada. Em projetos com versões anteriores, a dica continua valendo.
Quando a lógica é compartilhada#
Se duas telas precisam dos mesmos pedidos, tire o httpResource e o estado de dentro do componente e leve pra um serviço com @Injectable({ providedIn: 'root' }). A página continua smart, mas fica fina: ela só faz inject(OrdersStore) e liga os dados nos componentes dumb.
No React#
Os componentes visuais (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>
));
}No React, o papel do output é de uma função passada por props. A convenção é chamar de on + ação (onSelect, onChange). O papel do model() é o par value e onChange.
A página (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} />}
</>
);
}Um aviso sobre o useOrders: buscar dados com useEffect funciona e deixa o exemplo curto, mas a própria documentação do React recomenda, num app de verdade, usar a busca de dados do framework ou uma biblioteca com cache. A divisão smart e dumb não muda com isso: muda só o que tem dentro do hook.
O que o autor do padrão revisou#
O texto que popularizou a divisão no React é "Presentational and Container Components", do Dan Abramov, de 2015. Em 2019 ele colocou uma nota no topo: "I don't suggest splitting your components like this anymore". A explicação dele, resumida: o que ele mais gostava na divisão era separar a lógica com estado do resto do componente, e os hooks fazem isso sem obrigar a criar um componente a mais. Ele também conta que viu o padrão ser imposto sem necessidade, quase como regra religiosa.
Na prática, isso muda o desenho:
- A parte smart virou o hook.
useOrdersconcentra a busca e o estado de carregamento. Qualquer componente que precisar dos pedidos chama o hook, sem um container no meio. - Componentes dumb continuam ótimos.
OrderCardeOrderListseguem recebendo tudo por props, e é isso que os deixa fáceis de testar e reaproveitar. - O container ficou opcional.
OrdersPageainda existe porque é a tela, não porque o padrão manda.
Server Components: a divisão voltou#
Com React Server Components (num framework que suporta, como o App Router do Next.js), a divisão reaparece, agora por onde o código roda:
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} />
</>
);
}O componente do servidor é o smart: busca os dados perto do banco, e o código dele nem vai pro navegador. O componente com 'use client' cuida do filtro e da seleção, e os dumb continuam os mesmos de antes.
Angular e React lado a lado#
| Ideia | Angular 22 | React 19 |
|---|---|---|
| Receber dados | input() / input.required() | props |
| Avisar o pai | output() + .emit() | função por props (onSelect) |
| Valor nos dois sentidos | model() + [(valor)] | value + onChange |
| Buscar dados | httpResource ou serviço com inject() | hook, busca do framework ou Server Component |
| Derivar dados | computed() | cálculo direto no render |
| Lista | @for (...; track id) | .map() com key |
| Lista vazia | @empty | if antes do map |
| Evitar render à toa | OnPush, padrão desde a v22 | memo ou o React Compiler |
Erros comuns#
- O dumb que injeta "só um serviçozinho". Basta um
inject(HttpClient)ou umfetchdentro do cartão pra ele deixar de ser reaproveitável. Se precisa de dado, recebe por input. - O smart que vira deus. Uma página com 600 linhas de lógica não melhorou nada. Leve a lógica pra um serviço (Angular) ou hook (React) e deixe a página só ligando as peças.
- Prop drilling de cinco níveis. Passar o mesmo dado por quatro componentes que não usam é sinal de que algum lá embaixo pode ser smart, ou de que o dado merece um serviço (Angular) ou um contexto (React).
- Achar que dumb não pode ter estado. Estado visual, como um acordeão aberto, mora no próprio componente. O que não mora lá é dado de negócio.
- Nome de evento igual a evento do DOM.
select,changeeclickconfundem quem lê o template. PrefiraorderSelected,statusChange. - Dividir tudo por regra. Um componente pequeno que busca e mostra três linhas não precisa virar dois arquivos.
Quando vale a pena#
Minha recomendação:
- Sempre separe componentes visuais que aparecem em mais de uma tela. Eles devem receber tudo por input ou props.
- Quase sempre concentre busca de dados e estado da tela num lugar só: a página, um serviço ou um hook.
- No React, prefira hook a componente container. Crie o container só quando ele for, de fato, a tela.
- No Angular, a divisão sai quase de graça com signals. Aproveite, mas não crie um componente só pra "obedecer o padrão".
- Não divida componentes pequenos e usados uma vez só. Separação tem custo de leitura também.
Checklist#
- Componentes visuais recebem dados só por
inputou props. - Componentes visuais avisam o pai por
outputou funçãoon..., sem decidir o que acontece. - Nenhum componente visual importa HTTP, serviço de dados ou roteador.
- Busca de dados e estado da tela num lugar só (página, serviço ou hook).
- No Angular:
input.requiredpro que é obrigatório,readonlyem inputs e outputs,protectedno que é só do template. - No React: lógica com estado em hooks, props
on...pros eventos. - Eventos com nomes que não colidem com os do DOM.
- Nada dividido só por regra.
Referências#
Comentários
Pra comentar, entre com sua conta do GitHub.
Leia também

Front-end8 min de leitura
camelCase, PascalCase, kebab-case e snake_case: quando usar

Front-end10 min de leitura
Signals no Angular 22: signal, computed, effect e além

Front-end10 min de leitura
Storybook: como começar e até onde vale a pena ir