Todos os artigos

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.

Também em English, Español, Français

"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 input ou props e só avisa, por evento, que algo aconteceu.
  • No Angular, a divisão encaixa muito bem: input(), output() e model() no dumb, httpResource e computed no smart. Desde a versão 22, o OnPush já é 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)
Dadosbusca na API, no serviço, no storerecebe tudo por input ou props
Decisõesdecide o que acontece num cliquesó avisa que houve o clique
Estadoestado da tela (filtro, seleção, carregando)no máximo estado visual (aberto, fechado)
Dependênciasserviços, HTTP, roteadornenhuma, além de outros componentes visuais
Reusoquase nenhum, é a cola da telaalto, funciona em qualquer tela
Testeprecisa simular a APIbasta 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 order funciona 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 input ou 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.

Um só componente sabe de onde vêm os dados. Os outros recebem e avisam
  • 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:

order.ts
export type OrderStatus = 'pending' | 'paid' | 'shipped';
 
export interface Order {
  id: string;
  customer: string;
  total: number;
  status: OrderStatus;
}

No Angular#

O cartão (dumb)#

order-card.ts
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.
  • readonly em 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)#

order-list.ts
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.

status-filter.ts
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)#

orders-page.ts
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);
  });
}
  • httpResource faz a chamada HTTP e expõe value(), isLoading() e error() como signals. Ele é API estável desde o Angular 22. Precisa de provideHttpClient() na configuração da aplicação.
  • computed deriva a lista filtrada do filtro e dos pedidos. Muda o filtro, a lista se recalcula sozinha.
  • protected nos 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)#

OrderCard.tsx
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>
  );
}
OrderList.tsx
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} />
  ));
}
StatusFilter.tsx
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)#

useOrders.ts
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 };
}
OrdersPage.tsx
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. useOrders concentra 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. OrderCard e OrderList seguem recebendo tudo por props, e é isso que os deixa fáceis de testar e reaproveitar.
  • O container ficou opcional. OrdersPage ainda 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:

orders-page.tsx
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} />;
}
orders-view.tsx
'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#

IdeiaAngular 22React 19
Receber dadosinput() / input.required()props
Avisar o paioutput() + .emit()função por props (onSelect)
Valor nos dois sentidosmodel() + [(valor)]value + onChange
Buscar dadoshttpResource ou serviço com inject()hook, busca do framework ou Server Component
Derivar dadoscomputed()cálculo direto no render
Lista@for (...; track id).map() com key
Lista vazia@emptyif antes do map
Evitar render à toaOnPush, padrão desde a v22memo ou o React Compiler

Erros comuns#

  • O dumb que injeta "só um serviçozinho". Basta um inject(HttpClient) ou um fetch dentro 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, change e click confundem quem lê o template. Prefira orderSelected, 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 input ou props.
  • Componentes visuais avisam o pai por output ou função on..., 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.required pro que é obrigatório, readonly em inputs e outputs, protected no 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#

  • Front-end
  • angular
  • react
  • componentes
  • arquitetura
  • signals

Escrito por

Engenheira de software e designer. Escrevo sobre o que encontro construindo apps, APIs e produtos.

Comentários

Pra comentar, entre com sua conta do GitHub.