Front-end12 min de lectura
Smart y dumb components en Angular y React, en 2026
Qué separa un componente smart de uno dumb, el mismo ejemplo en Angular 22 y React 19, lo que revisó el propio autor del patrón y cuándo la división todavía vale.

"Smart y dumb components" es de esos temas que aparecen en entrevistas, en code review y en toda discusión sobre arquitectura de front. A veces con otro nombre: container y presentational. La idea es simple, pero mucho cambió desde que se hizo famosa, y si la aprendiste en 2016 probablemente la sigues aplicando a la manera antigua.
Este post explica la división, muestra el mismo ejemplo en Angular y en React con la forma actual de cada uno y cuenta algo que poca gente sabe: el autor del texto que popularizó el patrón en React escribió, años después, que ya no recomienda dividir los componentes así.
Un aviso honesto: los ejemplos se compilaron y probaron en Angular 22.3 y React 19.3. Cada uno tiene una prueba que carga los pedidos, filtra y selecciona uno, y las dos pasan.
TL;DR#
- Smart sabe de dónde vienen los datos y decide qué hacer con ellos. Dumb recibe todo por
inputo props y solo avisa, con un evento, que algo pasó. - En Angular, la división encaja muy bien:
input(),output()ymodel()en el dumb,httpResourceycomputeden el smart. Desde la versión 22,OnPushya es el predeterminado. - En React, la parte "smart" hoy suele ser un hook, no un componente container. El propio Dan Abramov revisó su artículo en 2019 para decirlo.
- Con Server Components, la división volvió con otra cara: el componente del servidor busca los datos y el componente del cliente se encarga de la interacción.
- No dividas por dogma. Separa cuando la lógica de datos estorba la lectura de la pantalla o cuando el componente visual tiene que reutilizarse.
Qué es cada uno#
| Smart (container) | Dumb (presentational) | |
|---|---|---|
| Datos | los busca en la API, el servicio o el store | recibe todo por input o props |
| Decisiones | decide qué pasa en un clic | solo avisa del clic |
| Estado | estado de la pantalla (filtro, selección, carga) | como mucho estado visual (abierto, cerrado) |
| Dependencias | servicios, HTTP, router | ninguna, aparte de otros componentes visuales |
| Reutilización | casi ninguna, es el pegamento de la pantalla | alta, funciona en cualquier pantalla |
| Pruebas | hay que simular la API | basta con pasar datos y revisar el HTML |
Fíjate en la fila del estado: un componente dumb puede tener estado, siempre que sea de interfaz, como un menú abierto o cerrado. Lo que no puede es saber de dónde vienen los datos ni qué hacer con ellos.
Por qué separar#
- El componente visual se vuelve reutilizable. Una tarjeta de pedido que solo recibe un
orderfunciona en la lista, en el detalle, en la vista previa de un correo. - Probar sale barato. Para probar el dumb, pasas datos y revisas el HTML. Sin simular API, sin servicio falso.
- Cambiar la fuente de datos no toca la pantalla. Si cambia la API, o si los datos pasan a venir de caché, solo cambia el smart.
- Queda claro quién manda. Los datos bajan por
inputo props, los eventos suben. Cuando algo falla, sabes dónde buscar.
El ejemplo: una lista de pedidos#
Los dos ejemplos arman la misma pantalla: una lista de pedidos con filtro por estado y selección de un pedido.
OrdersPage(smart): busca los pedidos, guarda el filtro y qué pedido está seleccionado.StatusFilter(dumb): muestra los botones de estado y avisa cuando cambia.OrderList(dumb): dibuja la lista o el aviso de vacío.OrderCard(dumb): dibuja un pedido y avisa cuando hacen clic en "Details".
El modelo es el mismo en los dos:
export type OrderStatus = 'pending' | 'paid' | 'shipped';
export interface Order {
id: string;
customer: string;
total: number;
status: OrderStatus;
}En Angular#
La tarjeta (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>()obliga a quien usa el componente a pasar el pedido. Si se olvida, el error aparece en el build, no en producción.input(false)es un input opcional con valor predeterminado.output<string>()es el evento. El componente solo emite el id y no sabe qué pasará después.readonlyen inputs y outputs es una recomendación de la guía de estilo de Angular: impide que alguien sobrescriba lo que Angular completa.
Un detalle de nombre: el evento se llama orderSelected, no select. La guía de Angular pide evitar nombres que choquen con eventos del DOM, y select es uno de ellos.
La lista y el 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>();
}La lista no decide nada: recibe los pedidos, marca el seleccionado y pasa el evento hacia arriba. El @empty se encarga del estado vacío sin un @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'];
}El filtro usa model(), un input que el propio componente también puede cambiar. Desde afuera, quien lo usa lo conecta en los dos sentidos con [(status)]. Es la forma de Angular de hacer el par "valor y evento de cambio" en una sola línea.
La 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);
});
}httpResourcehace la llamada HTTP y exponevalue(),isLoading()yerror()como signals. Es API estable desde Angular 22. NecesitaprovideHttpClient()en la configuración de la aplicación.computedderiva la lista filtrada a partir del filtro y los pedidos. Cambia el filtro, la lista se recalcula sola.protecteden los miembros que solo usa la plantilla es otra recomendación de la guía de estilo: no forman parte de la API pública del componente.
Y lo que quedó afuera también importa: ningún componente dumb importa HttpClient, un servicio ni el router. Si mañana los pedidos llegan por WebSocket, solo cambia OrdersPage.
¿Y el OnPush?#
Durante años, el consejo fue "pon ChangeDetectionStrategy.OnPush en los componentes dumb", para que Angular solo los revisara cuando cambiaran sus inputs. En Angular 22, OnPush pasó a ser el predeterminado, y la estrategia antigua, ahora llamada Eager, es la que tienes que pedir. Por eso los ejemplos de arriba no declaran nada. En proyectos con versiones anteriores, el consejo sigue valiendo.
Cuando la lógica se comparte#
Si dos pantallas necesitan los mismos pedidos, saca el httpResource y el estado del componente y llévalos a un servicio con @Injectable({ providedIn: 'root' }). La página sigue siendo smart, pero delgada: solo hace inject(OrdersStore) y conecta los datos con los componentes dumb.
En React#
Los componentes visuales (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, el papel del output lo cumple una función pasada por props. La convención es llamarla on + acción (onSelect, onChange). El papel del model() lo cumple el par value y onChange.
La 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} />}
</>
);
}Un aviso sobre useOrders: buscar datos con useEffect funciona y deja el ejemplo corto, pero la propia documentación de React recomienda, en una app real, usar la búsqueda de datos del framework o una biblioteca con caché. La división smart y dumb no cambia por eso: solo cambia lo que hay dentro del hook.
Lo que revisó el autor del patrón#
El texto que popularizó la división en React es "Presentational and Container Components", de Dan Abramov, de 2015. En 2019 agregó una nota al principio: "I don't suggest splitting your components like this anymore". Su explicación, en resumen: lo que más le gustaba de la división era separar la lógica con estado del resto del componente, y los hooks hacen eso sin obligarte a crear un componente más. También cuenta que vio el patrón impuesto sin necesidad, casi como una regla religiosa.
En la práctica, eso cambia el diseño:
- La parte smart pasó a ser el hook.
useOrdersconcentra la búsqueda y el estado de carga. Cualquier componente que necesite los pedidos llama al hook, sin un container en el medio. - Los componentes dumb siguen siendo excelentes.
OrderCardyOrderListsiguen recibiendo todo por props, y eso es lo que los hace fáciles de probar y reutilizar. - El container pasó a ser opcional.
OrdersPagesigue existiendo porque es la pantalla, no porque lo mande el patrón.
Server Components: la división volvió#
Con React Server Components (en un framework que los soporte, como el App Router de Next.js), la división reaparece, ahora según dónde corre el código:
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} />
</>
);
}El componente del servidor es el smart: busca los datos cerca de la base de datos, y su código ni siquiera llega al navegador. El componente con 'use client' se encarga del filtro y la selección, y los dumb siguen siendo los mismos.
Angular y React lado a lado#
| Idea | Angular 22 | React 19 |
|---|---|---|
| Recibir datos | input() / input.required() | props |
| Avisar al padre | output() + .emit() | función por props (onSelect) |
| Valor en los dos sentidos | model() + [(valor)] | value + onChange |
| Buscar datos | httpResource o servicio con inject() | hook, búsqueda del framework o Server Component |
| Derivar datos | computed() | cálculo directo en el render |
| Lista | @for (...; track id) | .map() con key |
| Lista vacía | @empty | if antes del map |
| Evitar renders de más | OnPush, predeterminado desde la v22 | memo o el React Compiler |
Errores comunes#
- El dumb que inyecta "solo un servicito". Basta un
inject(HttpClient)o unfetchdentro de la tarjeta para que deje de ser reutilizable. Si necesita datos, los recibe por input. - El smart que se vuelve dios. Una página con 600 líneas de lógica no mejoró nada. Lleva la lógica a un servicio (Angular) o a un hook (React) y deja que la página solo conecte las piezas.
- Prop drilling de cinco niveles. Pasar el mismo dato por cuatro componentes que no lo usan es señal de que alguno más abajo puede ser smart, o de que el dato merece un servicio (Angular) o un contexto (React).
- Creer que el dumb no puede tener estado. El estado visual, como un acordeón abierto, vive en el propio componente. Lo que no vive ahí son los datos de negocio.
- Nombres de eventos iguales a los del DOM.
select,changeyclickconfunden a quien lee la plantilla. PrefiereorderSelected,statusChange. - Dividir todo por regla. Un componente pequeño que busca y muestra tres líneas no necesita convertirse en dos archivos.
Cuándo vale la pena#
Mi recomendación:
- Siempre separa los componentes visuales que aparecen en más de una pantalla. Deben recibir todo por input o props.
- Casi siempre concentra la búsqueda de datos y el estado de la pantalla en un solo lugar: la página, un servicio o un hook.
- En React, prefiere un hook a un componente container. Crea el container solo cuando de verdad sea la pantalla.
- En Angular, la división sale casi gratis con signals. Aprovéchala, pero no crees un componente solo para "obedecer el patrón".
- No dividas componentes pequeños que se usan una sola vez. Separar también tiene un costo de lectura.
Checklist#
- Los componentes visuales reciben datos solo por
inputo props. - Los componentes visuales avisan al padre con
outputo una funciónon..., sin decidir qué pasa. - Ningún componente visual importa HTTP, un servicio de datos ni el router.
- La búsqueda de datos y el estado de la pantalla en un solo lugar (página, servicio o hook).
- En Angular:
input.requiredpara lo obligatorio,readonlyen inputs y outputs,protecteden lo que es solo de la plantilla. - En React: lógica con estado en hooks, props
on...para los eventos. - Eventos con nombres que no chocan con los del DOM.
- Nada dividido solo por regla.
Referencias#
Comentarios
Para comentar, entra con tu cuenta de GitHub.
Sigue leyendo

Front-end8 min de lectura
camelCase, PascalCase, kebab-case y snake_case: cuándo usar

Front-end10 min de lectura
Signals en Angular 22: signal, computed, effect y más

Front-end11 min de lectura
Storybook: cómo empezar y hasta dónde vale la pena ir