Todos los artículos

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.

También en Português, English, Français

"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 input o props y solo avisa, con un evento, que algo pasó.
  • En Angular, la división encaja muy bien: input(), output() y model() en el dumb, httpResource y computed en el smart. Desde la versión 22, OnPush ya 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)
Datoslos busca en la API, el servicio o el storerecibe todo por input o props
Decisionesdecide qué pasa en un clicsolo avisa del clic
Estadoestado de la pantalla (filtro, selección, carga)como mucho estado visual (abierto, cerrado)
Dependenciasservicios, HTTP, routerninguna, aparte de otros componentes visuales
Reutilizacióncasi ninguna, es el pegamento de la pantallaalta, funciona en cualquier pantalla
Pruebashay que simular la APIbasta 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 order funciona 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 input o 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.

Solo un componente sabe de dónde vienen los datos. Los demás reciben y avisan
  • 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:

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

En Angular#

La tarjeta (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>() 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.
  • readonly en 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)#

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>();
}

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.

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'];
}

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)#

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 hace la llamada HTTP y expone value(), isLoading() y error() como signals. Es API estable desde Angular 22. Necesita provideHttpClient() en la configuración de la aplicación.
  • computed deriva la lista filtrada a partir del filtro y los pedidos. Cambia el filtro, la lista se recalcula sola.
  • protected en 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)#

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>
  ));
}

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)#

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} />}
    </>
  );
}

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. useOrders concentra 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. OrderCard y OrderList siguen recibiendo todo por props, y eso es lo que los hace fáciles de probar y reutilizar.
  • El container pasó a ser opcional. OrdersPage sigue 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:

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} />
    </>
  );
}

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#

IdeaAngular 22React 19
Recibir datosinput() / input.required()props
Avisar al padreoutput() + .emit()función por props (onSelect)
Valor en los dos sentidosmodel() + [(valor)]value + onChange
Buscar datoshttpResource o servicio con inject()hook, búsqueda del framework o Server Component
Derivar datoscomputed()cálculo directo en el render
Lista@for (...; track id).map() con key
Lista vacía@emptyif antes del map
Evitar renders de másOnPush, predeterminado desde la v22memo o el React Compiler

Errores comunes#

  • El dumb que inyecta "solo un servicito". Basta un inject(HttpClient) o un fetch dentro 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, change y click confunden a quien lee la plantilla. Prefiere orderSelected, 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 input o props.
  • Los componentes visuales avisan al padre con output o una función on..., 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.required para lo obligatorio, readonly en inputs y outputs, protected en 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#

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

Escrito por

Ingeniera de software y diseñadora. Escribo sobre lo que encuentro construyendo apps, APIs y productos.

Comentarios

Para comentar, entra con tu cuenta de GitHub.