Deja de usar useEffect para datos derivados: calcúlalos en el render
Guía/ 12 min de lectura
Si un valor sale de props o estado, no lo copies con useEffect: calcúlalo en el render. Lo medimos en Chromium con React 19: un render menos y ningún valor desfasado.
- React
- JavaScript
En este artículo (7)
No uses useEffect para datos derivados. Si un valor se puede calcular a partir de props o estado, como el total del carrito o una lista filtrada, calcúlalo durante el render. Con un efecto, React renderiza con el valor viejo, ejecuta el efecto y vuelve a renderizar: un render extra y un momento con datos desincronizados.
En este artículo medimos cinco casos típicos de una tienda con React 19 en Chromium, contando renders de verdad, y vemos cuándo sí conviene useMemo. Si trabajas con Next.js, revisa también dónde poner use client: los efectos y useMemo solo funcionan en componentes de cliente.
El doble render de useEffect y los estados desincronizados
Este es el patrón que queremos quitar. El total del carrito se guarda en un estado y un efecto lo recalcula cada vez que cambian los productos:
export function CartTotalBefore({ items }) {
const [total, setTotal] = useState(0);
useEffect(() => {
setTotal(items.reduce((sum, item) => sum + item.price * item.qty, 0));
}, [items]);
return <p>{items.length} items · total {(total / 100).toFixed(2)}</p>;
}
useState(0)crea una segunda fuente de verdad: el total ya se puede sacar deitems, pero ahora también vive aparte.- El efecto corre después de que React aplica el resultado al DOM, y solo entonces calcula el total.
setTotalprograma otro render. Hasta que ocurre, la pantalla muestra los productos nuevos con el total viejo.- Los importes van en centavos;
toFixed(2)los muestra con dos decimales.
La guía oficial You Might Not Need an Effect explica por qué es ineficiente: cuando cambia el estado, React llama a tus componentes, aplica el resultado al DOM (el commit) y después corre los efectos. Si un efecto actualiza el estado de inmediato, todo el proceso vuelve a empezar desde cero.
Lo medimos. Empaquetamos los ejemplos de este artículo con esbuild, React 19.0 y react-dom del mismo proyecto, y los corrimos en Chromium 151 con Playwright. Un contador registraba cada llamada al componente y un <Profiler> de React guardaba el texto del DOM después de cada commit. Al hacer clic para agregar un tercer producto de 2.50 a un carrito de 12.50:
Desliza la figura para verla completa
- Con el efecto: 2 renders y 2 commits. El primer commit dejó en el DOM «3 items · total 12.50», un total que no correspondía a los productos. El segundo lo corrigió a 15.00.
- Calculado en el render: 1 render y 1 commit, con «3 items · total 15.00» desde el principio.
¿Se llega a ver el valor viejo? Depende. Según la referencia de useEffect, si el efecto no lo causó una interacción, React normalmente deja que el navegador pinte antes de correrlo: al montar, el «total 0.00» puede llegar a la pantalla. Si lo causó un clic, React puede correr el efecto antes de pintar. Pero el render extra se hace igual, y cualquier código que lea el total en ese primer render, como un aviso de envío gratis, trabaja con un número equivocado.
No lo confundas con el doble render de StrictMode
Nuestras mediciones son sin StrictMode. En desarrollo, StrictMode llama dos veces a cada componente para encontrar renders impuros y corre una vez más cada efecto, pero solo en desarrollo; no afecta al build de producción. Con StrictMode activo contamos 4 llamadas con el efecto y 2 sin él, y los commits siguieron siendo 2 y 1. En el build de producción, sin StrictMode, los números fueron iguales que en desarrollo: 2 renders con el efecto y 1 sin él. El render de más del efecto es real, también en producción. Si usas Next.js con App Router, StrictMode está activo por defecto desde la versión 13.5.1, según la documentación de reactStrictMode.
Calcular durante el render
La regla de la documentación de React es directa: si algo se puede calcular a partir de las props o el estado que ya tienes, no lo pongas en el estado; calcúlalo durante el render. El mismo componente queda así:
export function CartTotal({ items }) {
const total = items.reduce((sum, item) => sum + item.price * item.qty, 0);
return <p>{items.length} items · total {(total / 100).toFixed(2)}</p>;
}
- Sin
useStateniuseEffect:totales una constante que se recalcula en cada render. - Como sale de
itemsen el mismo render, no puede quedar desfasada. - El JSX no cambia. Por eso el texto final de las dos versiones fue idéntico en nuestra prueba.
Desliza la figura para verla completa
Según la guía, así el código es más rápido (evitas las actualizaciones en cascada), más simple (quitas código) y con menos errores (no hay dos estados que se desincronicen). Dos variantes del mismo principio que vale la pena conocer: para reiniciar todo el estado cuando cambia una prop, pásale una key distinta al componente; y en lugar de guardar el objeto seleccionado, guarda su id y búscalo durante el render.
Cuándo sí usar useMemo
Calcular en cada render está bien casi siempre. La documentación sugiere medir con console.time y considerar useMemo si el cálculo suma 1 ms o más; en general, si no creas ni recorres miles de objetos, probablemente no es costoso. Este catálogo tiene un buscador, y cada tecla vuelve a renderizar el componente:
export function Catalog({ products }) {
const [query, setQuery] = useState("");
const sorted = useMemo(() => products.toSorted((a, b) => a.price - b.price), [products]);
const visible = sorted.filter((p) => p.name.includes(query)).slice(0, 20);
return (
<>
<input aria-label="Search" value={query} onChange={(e) => setQuery(e.target.value)} />
<ol>{visible.map((p) => <li key={p.id}>{p.name}</li>)}</ol>
</>
);
}
queryes el texto del buscador: cambia con cada tecla.useMemoguarda el resultado de ordenar y solo lo recalcula si cambiaproducts. React compara cada dependencia conObject.is.toSorteddevuelve un arreglo nuevo;sort()ordenaría en su lugar el arreglo que llegó por props.- El filtro por texto sí corre en cada tecla, porque depende de
query. slice(0, 20)limita lo que se pinta a 20 productos.
Lo medimos con 20,000 productos (cantidad ilustrativa), build de producción y tres teclas en el buscador, como recomienda la guía: en producción y también con la CPU limitada 4× desde las herramientas de Chromium. Para contar sin tocar el componente, envolvimos Array.prototype.toSorted en la página de prueba. Son mediciones locales de laboratorio, de dos corridas:
| Catálogo de 20,000 productos | Ordenamientos al escribir 3 letras | Tiempo por ordenamiento |
|---|---|---|
Sin useMemo | 3 | 3–5 ms; 14–25 ms con CPU 4× más lenta |
Con useMemo | 0 | No se ordena al escribir |
| Montaje, en los dos casos | 1 | El mismo: useMemo no acelera el primer render |
Ese es el caso que la referencia de useMemo describe como valioso: un cálculo notoriamente lento cuyas dependencias casi no cambian. También sirve cuando pasas el valor a un componente envuelto en memo o cuando es dependencia de otro hook. Fuera de esos casos no aporta nada, y la referencia es clara en otro punto: usa useMemo solo como optimización. Si tu código no funciona sin él, el problema está en otra parte.
5 ejemplos de antes y después (total del carrito, filtros, nombre completo, ordenamiento, conteos)
Los cinco son componentes reales que corrimos lado a lado. En todos, la versión con efecto hizo 2 renders al montar y 2 al actualizar, y la versión calculada en el render hizo 1 y 1, con el mismo texto final:
| Ejemplo | Con useEffect (montar / actualizar) | En el render | Lo que dejó el commit intermedio |
|---|---|---|---|
| Total del carrito | 2 / 2 renders | 1 / 1 | «3 items · total 12.50» en vez de 15.00 |
| Filtros | 2 / 2 renders | 1 / 1 | Lista vacía al montar; la categoría anterior al cambiar |
| Nombre completo | 2 / 2 renders | 1 / 1 | «Ana López» con «Beatriz» ya escrito en el campo |
| Ordenamiento | 2 / 2 renders | 1 / 1 | Lista vacía al montar; el orden anterior al cambiar |
| Conteos | 2 / 2 renders | 1 / 1 | «0 pending · 0 shipped» al montar |
1. Total del carrito
Es el ejemplo de las secciones anteriores; aquí van las dos versiones juntas, tal como las corrimos:
// 1. Cart total — before
export function CartTotalBefore({ items }) {
const [total, setTotal] = useState(0);
useEffect(() => {
setTotal(items.reduce((sum, item) => sum + item.price * item.qty, 0));
}, [items]);
return <p>{items.length} items · total {(total / 100).toFixed(2)}</p>;
}
// 1. Cart total — after
export function CartTotal({ items }) {
const total = items.reduce((sum, item) => sum + item.price * item.qty, 0);
return <p>{items.length} items · total {(total / 100).toFixed(2)}</p>;
}
- Antes: un estado y un efecto para algo que una línea calcula.
- Después:
reducesuma precio por cantidad en el mismo render.
2. Filtros
// 2. Filters — before
export function ProductListBefore({ products, category }) {
const [visible, setVisible] = useState([]);
useEffect(() => {
setVisible(products.filter((p) => p.category === category && p.stock > 0));
}, [products, category]);
return <ul>{visible.map((p) => <li key={p.id}>{p.name}</li>)}</ul>;
}
// 2. Filters — after
export function ProductList({ products, category }) {
const visible = products.filter((p) => p.category === category && p.stock > 0);
return <ul>{visible.map((p) => <li key={p.id}>{p.name}</li>)}</ul>;
}
- Antes:
visibleempieza vacío, así que el primer commit pinta una lista sin productos. - Después:
filtercorre en el render con la categoría actual y solo deja productos con stock.
3. Nombre completo
// 3. Full name — before
const [firstName, setFirstName] = useState("Ana");
const [lastName, setLastName] = useState("López");
const [fullName, setFullName] = useState("");
useEffect(() => {
setFullName(firstName + " " + lastName);
}, [firstName, lastName]);
// 3. Full name — after
const [firstName, setFirstName] = useState("Ana");
const [lastName, setLastName] = useState("López");
const fullName = firstName + " " + lastName;
- Antes: es el ejemplo de la documentación de React.
fullNamees estado redundante y, al escribir, el primer render muestra el nombre anterior. - Después: una concatenación. El JSX con los dos campos es igual en ambas versiones.
4. Ordenamiento
// 4. Sorting — before
export function SortedProductsBefore({ products, sortBy }) {
const [sorted, setSorted] = useState([]);
useEffect(() => {
setSorted(products.toSorted((a, b) => a[sortBy] - b[sortBy]));
}, [products, sortBy]);
return <ol>{sorted.map((p) => <li key={p.id}>{p.name}</li>)}</ol>;
}
// 4. Sorting — after
export function SortedProducts({ products, sortBy }) {
const sorted = products.toSorted((a, b) => a[sortBy] - b[sortBy]);
return <ol>{sorted.map((p) => <li key={p.id}>{p.name}</li>)}</ol>;
}
- Antes: al cambiar
sortBy, el primer commit todavía muestra el orden anterior. - Después: toSorted crea un arreglo nuevo en cada render. Con listas largas, envuélvelo en
useMemocomo en el catálogo.
5. Conteos
// 5. Counts — before
export function OrderCountsBefore({ orders }) {
const [pending, setPending] = useState(0);
const [shipped, setShipped] = useState(0);
useEffect(() => {
setPending(orders.filter((o) => o.status === "pending").length);
setShipped(orders.filter((o) => o.status === "shipped").length);
}, [orders]);
return <p>{pending} pending · {shipped} shipped</p>;
}
// 5. Counts — after
export function OrderCounts({ orders }) {
const pending = orders.filter((o) => o.status === "pending").length;
const shipped = orders.filter((o) => o.status === "shipped").length;
return <p>{pending} pending · {shipped} shipped</p>;
}
- Antes: dos estados y dos
seten el mismo efecto. React los agrupa en un solo render extra, pero siguen siendo dos copias que mantener. - Después: dos
filter(...).length. Si los pedidos son miles y el componente se renderiza a menudo, mide antes de memoizar.
Desliza la figura para verla completa
Errores comunes
- Copiar props en el estado «para tenerlas a mano». Cada copia es un valor más que puede quedar desfasado. Si sale de props, calcúlalo.
- Ordenar con
sort()los datos que llegan por props.sort()modifica el arreglo original. UsatoSorted()o copia antes. - Envolver todo en
useMemopor si acaso. Según su referencia, fuera de los casos de cálculo lento,memoo dependencia de otro hook, no aporta nada y hace el código más difícil de leer. - Usar
useMemopara arreglar un bug. Es solo una optimización: React puede descartar el valor guardado. Si sin él falla, arregla la causa. - Medir el rendimiento en desarrollo. StrictMode duplica las llamadas. La guía recomienda medir con un build de producción y en un dispositivo como el de tus usuarios.
- Encadenar efectos. Un efecto que cambia un estado que dispara otro efecto multiplica los renders. Si la causa es una acción del usuario, haz todo en el manejador del evento.
- Reiniciar estado con un efecto cuando cambia una prop. Pasa una
keydistinta y React reinicia el componente sin el render extra.
Preguntas frecuentes
¿Por qué mi componente se renderiza dos veces en desarrollo?
Casi siempre por StrictMode: en desarrollo llama dos veces a cada componente y corre una vez más cada efecto, y no pasa en producción. El render extra de un efecto que actualiza el estado es otro problema: ese sí ocurre en producción, como medimos.
¿Entonces cuándo sí uso useEffect?
Para sincronizar con algo externo a React: una conexión de red, una API del navegador o un widget que no es de React. Si el código debe correr porque el usuario hizo algo, va en el manejador del evento. También puedes pedir datos con un efecto, pero necesitas limpieza para evitar condiciones de carrera.
¿El React Compiler hace innecesario useMemo?
La referencia de useMemo dice que el compilador memoiza valores y funciones automáticamente y reduce la necesidad de llamadas manuales. Aun así, un valor derivado no debería vivir en un estado aparte: eso no es un problema de memoización.
¿Calcular en cada render no es más lento?
Para sumas, filtros y conteos de decenas o cientos de elementos, no se nota. En nuestra prueba, ordenar 20,000 productos costó entre 3 y 5 ms: ahí sí conviene useMemo. Mide con console.time antes de decidir.
Checklist
- Ningún estado guarda algo que se pueda calcular de props u otro estado.
- No hay efectos cuyo único trabajo sea llamar a un
setcon datos derivados. useMemosolo envuelve cálculos que mediste en 1 ms o más, en producción.- Los ordenamientos usan
toSorted()o una copia, nuncasort()sobre props. - Lo que causa el usuario va en el manejador del evento, no en un efecto.
- Para reiniciar un componente cuando cambia una prop, usas
key. - Los efectos que quedan sincronizan con algo externo y tienen limpieza.
Calcular durante el render deja menos código, un render menos y ningún valor desfasado. Si tu proyecto es Next.js, sigue con dónde poner use client para que estos componentes solo carguen JavaScript donde hace falta, y si tu botón de agregar al carrito tarda en responder, revisa cómo medir y arreglar su INP.
¿Viste esto en Instagram? Comenta EFFECT en el Reel y te mando la guía.
Escrito por

Publicado el 30 de octubre de 2026 · actualizado el 1 de noviembre de 2026