StackPractices
intermediate Por Mathias Paulenko

Guía completa de optimización de rendimiento en React

Optimiza aplicaciones React: memoización, virtualización, división de código, análisis del bundle, React Profiler, características concurrentes y Core Web Vitals.

Introducción

React es rápido por defecto. El reconciliador es bueno, el scheduler es bueno, y para la mayoría de las aplicaciones el framework hace su trabajo sin que nadie tenga que pensar en ello. Los problemas de rendimiento aparecen más tarde: cuando la aplicación ha crecido, cuando alguien envuelve todas las listas en un contexto, cuando el bundle se duplica en silencio porque una librería de gráficos terminó en la página de inicio.

Esta guía es para ese momento: puntuaciones de Lighthouse que bajan, una animación a 60fps que se convierte en una presentación de diapositivas en un móvil de gama media, una tabla de 5.000 filas que tarda segundos en hacer scroll. La idea rectora es simple: perfila primero, memoiza después. Los valores por defecto de React ya son sensatos, y la mayoría de las «optimizaciones» a las que la gente recurre (envolverlo todo en useMemo, memoizar cada componente) cuestan más de lo que ahorran. Lo que sigue explica cómo medir adónde va realmente el tiempo y después cubre las técnicas que importan una vez que lo sabes: memoización, virtualización, división de código, análisis del bundle, gestión de estado y las características concurrentes pensadas exactamente para este tipo de problema.

Cuándo usar esta guía

Esta guía está pensada para desarrolladores de React de nivel intermedio que trabajan en una aplicación que ya existe y ya se siente lenta —o cuyas métricas van en la dirección equivocada—. Si sabes leer un árbol de componentes y tienes una build de producción que medir, todo lo que hay aquí aplica. No hace falta ser especialista en rendimiento; sí hace falta un profiler y una línea base honesta.

Sáltala —o al menos échale un vistazo rápido— en algunos casos. Si tu aplicación es pequeña, renderiza rápido y saca en verde en Core Web Vitals, nada de esto la hará notablemente más rápida: la optimización prematura es trabajo real que no produce ninguna ganancia visible para el usuario. Si la lentitud vive en el servidor (respuestas lentas de la API, consultas a base de datos, cold starts), React es la capa equivocada; arregla primero el backend y vuelve si el cliente sigue siendo el cuello de botella. Y si todavía estás aprendiendo los fundamentos de React, ponte cómodo con el renderizado y el estado antes de añadir memoización encima: optimizar un modelo mental que aún no tienes solo hace la confusión más cara.

Medir primero: cómo encontrar el cuello de botella real

Antes de tocar un solo useMemo, averigua adónde va el tiempo. Adivinar es la forma más común de que los equipos quemen semanas en trabajo de rendimiento de React: memoizan el componente que parecía sospechoso y descubren que el coste real era un bundle de 4MB o un proveedor de contexto tres niveles más arriba.

El flujo de trabajo que uso tiene cuatro pasos, y cada técnica de esta guía asume que sabes hacerlos.

1. Establece una línea base. Registra los números actuales antes de cambiar nada: Lighthouse o PageSpeed Insights para Core Web Vitals, el tamaño del bundle a partir de la salida de tu build y —para el rendimiento percibido— una grabación rápida del Profiler de la interacción que se siente lenta. Sin una línea base no puedes demostrar que una corrección funcionó, y acabarás discutiendo sobre mejoras que nadie puede medir.

2. Perfila el renderizado. En desarrollo, abre React DevTools y usa la pestaña Profiler. Muestra un flamegraph de qué componentes se renderizaron, cuánto tardó cada uno y por qué: cambiaron las props, cambió el estado, cambió el contexto o se volvió a renderizar el padre. La API de React Profiler hace lo mismo de forma programática cuando lo necesitas en código o en tests, y su documentación explica en detalle las insignias de «por qué se renderizó esto». Si necesitas mediciones en código en lugar de la interfaz de DevTools, el componente Profiler envuelve cualquier subárbol y reporta los tiempos de renderizado mediante un callback:

import { Profiler } from "react";

function onRenderCallback(id, phase, actualDuration, baseDuration, startTime, commitTime) {
  console.log(`${id} ${phase} took ${actualDuration}ms`);
}

function App() {
  return (
    <Profiler id="App" onRender={onRenderCallback}>
      <ExpensiveComponent />
    </Profiler>
  );
}

Las builds de desarrollo son considerablemente más lentas que las de producción, así que trata estos números como relativos, no absolutos —y recuerda que el Profiler solo funciona en builds de desarrollo.

3. Perfila el navegador. La pestaña Performance de Chrome DevTools registra todo lo que React no puede ver: evaluación de scripts, layout, paint y long tasks. Muchos informes de «React es lento» resultan ser layout thrashing o una dependencia pesada, y la pestaña Performance es donde se distingue una cosa de la otra.

4. Mide en producción. Las herramientas de desarrollo mienten un poco: las builds de desarrollo se comportan de forma distinta y van mucho más lentas. Envía datos de tiempos con la librería web-vitals o tu proveedor de RUM para ver LCP, INP y CLS tal como los experimentan los usuarios reales. Los datos de campo son lo que usa Google para posicionar y lo que los usuarios realmente sienten; los datos de laboratorio son con lo que depuras.

Solo cuando puedas nombrar el cuello de botella —«esta lista se re-renderiza con 5.000 filas en cada pulsación de tecla» en lugar de «la aplicación se siente lenta»— tiene sentido elegir una técnica. El resto de esta guía está organizado, aproximadamente, según dónde suele esconderse el coste en ese pipeline.

Cómo se propagan los re-renders

Entender los re-renders es el prerrequisito de cada decisión de memoización que viene después. Un componente se re-renderiza cuando pueden ocurrir tres cosas:

  • Cambio de estado — el componente que contiene el estado se re-renderiza, y por defecto todo su subárbol se re-renderiza con él.
  • Re-renderizado del padre — cuando un padre se re-renderiza, React re-renderiza cada hijo salvo que algo lo detenga: React.memo, un bailout por elemento idéntico o el hijo que simplemente no se vuelve a invocar.
  • Cambio de contexto — cada componente que consume un contexto se re-renderiza cuando cambia la referencia de value de ese contexto, sin importar qué campo interno haya cambiado.
flowchart diagram: State or props change

Esa tercera viñeta explica una parte enorme de los bugs de rendimiento de React en aplicaciones reales. El value de un contexto se compara por referencia (Object.is), así que value={{ user, theme }} construye un objeto nuevo en cada renderizado y notifica a todos los consumidores —incluidos los que solo leen theme y nunca tocan user—. Dividir los contextos y memoizar los valores (lo veremos en Optimización de la gestión de estado) suele ser la corrección de mayor impacto disponible, porque un proveedor mal colocado puede re-renderizar media árbol en cada pulsación de tecla.

Memoización

La memoización le dice a React «esta salida no ha cambiado, no repitas el trabajo». React te da tres herramientas para ello, y resuelven problemas distintos: confundirlas es el error más común de toda esta guía.

React.memo

memo envuelve un componente y evita re-renderizarlo cuando sus props son superficialmente iguales a las del renderizado anterior. Solo ayuda cuando el padre se re-renderiza pero las entradas del hijo no cambiaron —que es exactamente la situación que useCallback y las referencias estables existen para crear—.

import { memo } from "react";

const ExpensiveCard = memo(function ExpensiveCard({ title, description }) {
  return (
    <div className="card">
      <h3>{title}</h3>
      <p>{description}</p>
    </div>
  );
});

// Comparación personalizada para cuando la igualdad superficial es demasiado estricta
const MemoizedCard = memo(Card, (prevProps, nextProps) => {
  return prevProps.title === nextProps.title && prevProps.description === nextProps.description;
});

La documentación de React sobre memo merece la pena leerla antes de recurrir a una comparación personalizada: un comparador equivocado es una fábrica sutil de bugs, y la igualdad superficial es la correcta para casi todo.

useMemo

useMemo almacena en caché el resultado de un cálculo entre renderizados. La regla general: memoiza cuando el cálculo es costoso y sus entradas cambian menos a menudo de lo que el componente se renderiza. Filtrar u ordenar unos cientos de elementos en cada pulsación de tecla califica; concatenar dos strings, no.

import { useMemo } from "react";

function ProductList({ products, filter }) {
  const filtered = useMemo(() => {
    return products.filter((p) => p.category === filter);
  }, [products, filter]);

  return (
    <ul>
      {filtered.map((p) => (
        <li key={p.id}>{p.name}</li>
      ))}
    </ul>
  );
}

Una advertencia que conviene interiorizar: useMemo es una pista de rendimiento, no una garantía semántica. React puede descartar la caché en algunos casos —renderizado fuera de pantalla, presión de memoria futura—, así que no guardes valores cuya corrección dependa de que el memo sobreviva. Si la aplicación se rompe cuando React tira la caché, nunca fue un memo; era estado.

useCallback

useCallback hace con las funciones lo que useMemo hace con los valores: devuelve la misma referencia de función entre renderizados. Su único uso real es estabilizar una función pasada como prop a un hijo memoizado; si no, el hijo ve una prop «nueva» en cada renderizado y memo no puede ayudar.

import { memo, useCallback, useState } from "react";

const MemoizedButton = memo(function MemoizedButton({ onClick, count }) {
  return <button onClick={onClick}>Count: {count}</button>;
});

function Parent() {
  const [count, setCount] = useState(0);
  const [text, setText] = useState("");

  // Referencia estable: MemoizedButton no se re-renderiza cuando cambia el texto
  const handleClick = useCallback(() => {
    setCount((c) => c + 1);
  }, []);

  return (
    <div>
      <input value={text} onChange={(e) => setText(e.target.value)} />
      <MemoizedButton onClick={handleClick} count={count} />
    </div>
  );
}

La trampa aquí es hacerlo en todas partes. useCallback en un manejador pasado a un <button> normal no compra nada: el elemento del DOM se re-renderiza de todas formas. El beneficio solo existe en la frontera donde un componente memoizado sería derrotado por una prop de función recién creada, así que recurre a él ahí y en ningún otro sitio.

Cuándo NO memoizar

Esto merece su propio párrafo porque la sobre-memoización es el modo de fallo que veo más a menudo. Cada memo, useMemo y useCallback añade trabajo de comparación en cada renderizado; si lo que protege es barato, has añadido coste para no ahorrar nada. Salta la memoización cuando:

  • El componente es pequeño: unos pocos nodos del DOM, sin cómputo pesado. Re-renderizarlo es más rápido que comparar props.
  • Las props son primitivas que rara vez cambian: el comportamiento por defecto de React ya es correcto.
  • El componente se re-renderiza de todos modos porque cambió su propio estado o contexto: memo no puede detener eso.
  • El cálculo dentro de useMemo es trivial: a + b memoizado es más lento que simplemente calcularlo.
  • Lo haces «por si acaso». Perfila primero; añade memo donde el flamegraph muestre coste.

Una heurística útil: memoiza en los bordes —hojas caras, listas grandes, componentes situados bajo padres que cambian con frecuencia—. No memoices el tronco.

React Compiler y memoización automática

React 19 incluye el React Compiler, activado mediante un plugin de Babel (babel-plugin-react-compiler) y cada vez más activado por defecto en los frameworks que lo soportan. Memoiza automáticamente componentes, valores de hooks y props de callback en tiempo de build —aplicando de facto las decisiones de memo/useMemo/useCallback de arriba sin que las escribas—. Para equipos en React 19+, esto cambia el cálculo: la memoización escrita a mano deja de ser la primera herramienta y pasa a ser el recurso para los casos que el compilador no puede demostrar seguros.

Lo que el compilador maneja bien: componentes cuyas props son demostrablemente estables, derivaciones costosas dentro de componentes y props de callback que bajan por el árbol. Lo que no hace: arreglar problemas de arquitectura. Un proveedor de contexto que reconstruye un objeto enorme en cada renderizado sigue re-renderizando a todos sus consumidores. Una lista de 5.000 filas sigue renderizando 5.000 filas hasta que la virtualices. Un bundle de 4MB sigue siendo 4MB. El compilador optimiza renderizados; no cambia qué se renderiza.

Si estás en React 19 o lo estás evaluando, las guías complementarias cubren el resto de la versión: las características de React 19 para use(), las Actions y los nuevos hooks, y React Server Components para el modelo de renderizado que evita por completo los re-renders del cliente.

Para verificar que el compilador realmente ayuda, ejecuta el Profiler de React DevTools sobre la misma interacción antes y después de activarlo, y mira qué componentes hacen bailout. Si un componente que esperabas que estuviera memoizado no lo está, probablemente el compilador no pudo demostrar que sus entradas fueran estables —lo que suele significar que hay un objeto o una función inline creándose más arriba—. El useMemo manual sigue ganándose su sitio ahí, como corrección puntual y no como política general.

Virtualización (listas grandes)

Renderizar 1.000 filas de DOM funciona. Renderizar 10.000 no: el layout, el recálculo de estilos y la memoria escalan todos con el número de nodos, y el rendimiento del scroll colapsa mucho antes de que React en sí se convierta en el cuello de botella. La virtualización renderiza solo la porción visible más un pequeño búfer de overscan, posicionados de forma absoluta dentro de un elemento espaciador alto.

Tres opciones cubren la mayoría de los casos, y cambian simplicidad por flexibilidad:

EnfoqueIdeal paraCompromisos
react-windowListas de altura fija, la API más simpleSolo tamaños fijos; cadencia de releases más lenta últimamente
@tanstack/react-virtualAlturas variables, cuadrículas, tablas, contenedores de scroll personalizadosMás configuración; te encargas tú de más de las matemáticas de posicionamiento
CSS content-visibility: autoDocumentos y páginas largas, JS mínimoUn poco menos de control sobre la medición; verifica el soporte del navegador

Para una lista de altura fija con filas uniformes, react-window sigue siendo el camino más rápido hacia código funcionando: la receta Virtualizar listas largas con react-window lo recorre de principio a fin:

import { FixedSizeList } from "react-window";

function Row({ index, style, data }) {
  return (
    <div style={style}>
      {data[index].name} — {data[index].email}
    </div>
  );
}

function UserList({ users }) {
  return (
    <FixedSizeList
      height={600}
      itemCount={users.length}
      itemSize={50}
      width="100%"
      itemData={users}
    >
      {Row}
    </FixedSizeList>
  );
}

itemData importa más de lo que parece: pasar users a través de él mantiene las props de las filas estables durante el scroll, así que las filas memoizadas no se re-renderizan en cada avance del scroll. Cuando las filas varían en altura (mensajes de chat, tarjetas, texto de tabla con saltos de línea), recurre a @tanstack/react-virtual en su lugar:

import { useRef } from "react";
import { useVirtualizer } from "@tanstack/react-virtual";

function VariableHeightList({ items }) {
  const parentRef = useRef(null);

  const virtualizer = useVirtualizer({
    count: items.length,
    getScrollElement: () => parentRef.current,
    estimateSize: () => 80,
    overscan: 5,
  });

  return (
    <div ref={parentRef} style={{ height: 600, overflow: "auto" }}>
      <div style={{ height: virtualizer.getTotalSize(), position: "relative" }}>
        {virtualizer.getVirtualItems().map((virtualItem) => (
          <div
            key={virtualItem.key}
            style={{
              position: "absolute",
              top: 0,
              left: 0,
              width: "100%",
              transform: `translateY(${virtualItem.start}px)`,
            }}
          >
            {items[virtualItem.index].content}
          </div>
        ))}
      </div>
    </div>
  );
}

estimateSize no necesita ser exacto —el virtualizador mide los elementos reales y se autocorrige mientras haces scroll—, pero una estimación más cercana significa menos jitter al hacer scroll. overscan renderiza algunos elementos extra por encima y por debajo del viewport para que un scroll rápido no parpadee con espacios vacíos; 5–10 es lo típico.

Antes de recurrir a una librería, comprueba si necesitas virtualización en absoluto. Una lista larga pero estática funciona bien renderizada en el servidor con content-visibility: auto y cero JavaScript. Y si los usuarios necesitan encontrar filas arbitrarias rápido, la paginación o la búsqueda mientras escribes pueden superar a la virtualización: las listas virtualizadas se llevan mal con el buscador del navegador (Ctrl+F) y necesitan una semántica ARIA cuidadosa para lectores de pantalla, que las librerías manejan en su mayoría pero que conviene verificar.

División de código

La división de código es la técnica con la mejor relación esfuerzo-impacto para la mayoría de las aplicaciones React. En lugar de un solo bundle, divides el código en chunks que se cargan bajo demanda —normalmente por ruta, por funcionalidad pesada o por componente de uso poco frecuente—.

import { lazy, Suspense } from "react";
import { BrowserRouter, Routes, Route } from "react-router-dom";

const Home = lazy(() => import("./pages/Home"));
const About = lazy(() => import("./pages/About"));
const Product = lazy(() => import("./pages/Product"));

function PageLoader() {
  return <div>Loading page...</div>;
}

function App() {
  return (
    <BrowserRouter>
      <Suspense fallback={<PageLoader />}>
        <Routes>
          <Route path="/" element={<Home />} />
          <Route path="/about" element={<About />} />
          <Route path="/product/:id" element={<Product />} />
        </Routes>
      </Suspense>
    </BrowserRouter>
  );
}
flowchart diagram: User navigates to route

Dos reglas importan más que la sintaxis. Primero, lazy() debe llamarse a nivel de módulo: la documentación de React es explícita en que llamarlo durante el renderizado crea un nuevo tipo de componente cada vez, lo que remonta el subárbol y puede volver a descargar el chunk. Segundo, cada componente lazy necesita un límite Suspense por encima; sin él, React lanza un error.

La división a nivel de ruta te da las mayores ganancias porque la mayoría de los usuarios solo visita unas pocas rutas. La receta División de código y carga diferida en SPAs cubre el lado de Vite y Rollup para emitir chunks limpios con las cabeceras de caché correctas.

Para funcionalidades condicionales —un panel de administración, un modal de ajustes, un gráfico que solo abren algunos usuarios— divide el chunk pero mantén lazy a nivel de módulo:

import { lazy, Suspense } from "react";

// A nivel de módulo: se crea una vez, no en cada renderizado
const AdminPanel = lazy(() => import("./AdminPanel"));

function App({ showAdmin }) {
  return (
    <div>
      <Header />
      {showAdmin && (
        <Suspense fallback={<Loader />}>
          <AdminPanel />
        </Suspense>
      )}
    </div>
  );
}

El patrón de renderizado condicional importa: montar <Suspense> solo cuando hace falta significa que el fallback no parpadea para los usuarios que nunca ven la funcionalidad, y el chunk se descarga en la primera apertura en lugar de en la carga de la página. Si te descubres queriendo llamar a lazy() dentro de useMemo o useEffect, para: ese es el anti-patrón que esto sustituye.

Análisis del bundle

La división de código solo ayuda si sabes qué hay realmente en el bundle. Las herramientas son maduras y baratas: para proyectos Vite, rollup-plugin-visualizer emite un treemap interactivo de cada chunk después de vite build; para webpack, webpack-bundle-analyzer hace lo mismo contra dist/stats.json. La guía de optimización del tamaño del bundle profundiza en presupuestos, auditoría de dependencias y compresión —la versión corta aquí es: compila con estadísticas, encuentra a los mayores culpables y comprueba si se están importando de forma ansiosa en algún sitio donde no deberían—.

# Vite: el plugin visualizer escribe dist/stats.html después de la build
npm install --save-dev rollup-plugin-visualizer
// vite.config.js
import { visualizer } from "rollup-plugin-visualizer";

export default {
  plugins: [
    visualizer({
      open: true,
      filename: "dist/stats.html",
      gzipSize: true,
    }),
  ],
};

El interruptor gzipSize importa: muestra el tamaño que los usuarios descargan realmente tras la compresión. Un bundle de 2MB que se comprime a 600KB es un problema distinto de uno que se comprime a 1.8MB.

Optimización de imágenes

Las imágenes suelen ser los bytes más pesados de una página y la causa más común de un LCP pobre. La parte específica de React es pequeña pero conviene hacerla bien: reserva espacio con dimensiones explícitas para prevenir CLS, carga perezosa de las imágenes bajo el pliegue y decodificación asíncrona para que el trabajo de imágenes no bloquee el hilo principal.

import { useState } from "react";

function OptimizedImage({ src, alt, width, height }) {
  const [loaded, setLoaded] = useState(false);

  return (
    <div style={{ width, height, background: "#f0f0f0" }}>
      <img
        src={src}
        alt={alt}
        width={width}
        height={height}
        loading="lazy"
        decoding="async"
        onLoad={() => setLoaded(true)}
        style={{ opacity: loaded ? 1 : 0, transition: "opacity 0.3s" }}
      />
    </div>
  );
}

Algunas notas sobre lo que esto cubre y lo que no. loading="lazy" pospone las imágenes fuera de pantalla hasta que se acercan al viewport —no lo pongas en tu imagen LCP (normalmente el hero), o retrasarás la métrica que intentas mejorar; usa fetchpriority="high" ahí en su lugar—. El contenedor de dimensiones fijas previene el layout shift mientras la imagen carga. Para cualquier cosa más allá de esto —formatos modernos como AVIF y WebP, srcset responsive, redimensionado por CDN— la respuesta suele ser tu pipeline de imágenes o el componente integrado de un framework (next/image y similares), no React hecho a mano.

Optimización de la gestión de estado

El estado global es donde las aplicaciones React acumulan re-renders. Cada librería de estado resuelve el problema de suscripción de forma distinta, y la diferencia importa más que qué librería hayas elegido.

Optimización de selectores (Zustand)

El modelo de Zustand es simple: los componentes se suscriben a porciones del estado y solo se re-renderizan cuando cambia su porción. El error es suscribirse a todo el store: useStore() sin selector se re-renderiza con cualquier cambio de estado, que es comportamiento de contexto con pasos extra.

import { create } from "zustand";

const useStore = create((set) => ({
  user: null,
  posts: [],
  setPosts: (posts) => set({ posts }),
}));

// MAL — se re-renderiza con cualquier cambio de estado
function PostList() {
  const store = useStore();
  return <div>{store.posts.map((p) => <p key={p.id}>{p.title}</p>)}</div>;
}

// BIEN — solo se re-renderiza cuando cambian los posts
function PostList() {
  const posts = useStore((s) => s.posts);
  return <div>{posts.map((p) => <p key={p.id}>{p.title}</p>)}</div>;
}

Cuando un componente necesita varios campos, selecciónalos juntos con shallow de zustand/shallow para que la comparación sea por valor y no por referencia —si no, cambias un problema por otro—. El mismo principio aplica a Redux (useSelector con shallowEqual o reselect) y a los selectores de Jotai o TanStack Query: suscríbete de forma estrecha y deriva en el componente o en un selector memoizado.

División de contextos

React Context va bien para valores verdaderamente globales y que cambian poco: tema, idioma, sesión de autenticación. Se convierte en un problema de rendimiento cuando el estado que cambia con frecuencia se mete dentro: cada consumidor se re-renderiza en cada cambio, y no hay forma incorporada de seleccionar una porción. La solución es dividir por responsabilidad y memoizar los valores:

import { createContext, useContext, useMemo, useState } from "react";

// MAL — todos los consumidores se re-renderizan cuando cambia cualquiera de los dos valores
const AppContext = createContext();

function BadProvider({ children }) {
  const [user, setUser] = useState(null);
  const [theme, setTheme] = useState("light");
  return (
    <AppContext.Provider value={{ user, theme, setUser, setTheme }}>
      {children}
    </AppContext.Provider>
  );
}

// BIEN — contextos divididos, cada valor memoizado
const UserContext = createContext();
const ThemeContext = createContext();

function AppProvider({ children }) {
  const [user, setUser] = useState(null);
  const [theme, setTheme] = useState("light");

  // Sin useMemo estos objetos se reconstruyen en cada renderizado y
  // cada consumidor se re-renderiza aunque su propia porción no haya cambiado
  const userValue = useMemo(() => ({ user, setUser }), [user]);
  const themeValue = useMemo(() => ({ theme, setTheme }), [theme]);

  return (
    <UserContext.Provider value={userValue}>
      <ThemeContext.Provider value={themeValue}>
        {children}
      </ThemeContext.Provider>
    </UserContext.Provider>
  );
}

function useUser() {
  const ctx = useContext(UserContext);
  if (!ctx) throw new Error("useUser must be used within AppProvider");
  return ctx;
}

Incluso hecho correctamente, el contexto tiene un techo: difunde a todos los consumidores. Si una porción del estado se actualiza en cada pulsación de tecla y tiene decenas de consumidores por todo el árbol, un store con selectores superará al contexto siempre. El contexto es para «todos necesitan esto a veces»; los stores son para «muchos componentes necesitan porciones distintas a menudo».

Obtención de datos con use() y Suspense

El hook use() de React 19 lee una promesa o un contexto durante el renderizado y se suspende hasta que se resuelve —lo que significa que la obtención de datos puede vivir en el árbol de componentes en lugar de orquestarse mediante tríos de useEffect + useState—. Combinado con los límites de Suspense, obtienes estados de carga gratis y la capacidad de hacer streaming de la UI a medida que llegan los datos.

import { Suspense, use } from "react";

// Guarda la promesa por id para que los re-renders no la vuelvan a pedir
const userCache = new Map();

function getUser(id) {
  if (!userCache.has(id)) {
    userCache.set(id, fetch(`/api/users/${id}`).then((res) => {
      if (!res.ok) throw new Error("Failed to load user");
      return res.json();
    }));
  }
  return userCache.get(id);
}

function UserProfile({ userId }) {
  const user = use(getUser(userId));
  return <div>{user.name}</div>;
}

function App() {
  return (
    <Suspense fallback={<div>Loading user...</div>}>
      <UserProfile userId="42" />
    </Suspense>
  );
}

La caché importa más de lo que parece: use() lee lo que le pases, y si llamas a fetch inline en cada renderizado dispararás una petición por renderizado. Frameworks como Next.js lo manejan con deduplicación de peticiones y capas de caché; si lo haces a mano, el Map de arriba es la versión mínima viable. La referencia de use en React cubre en detalle las reglas de identidad de promesas.

Esto no es un reemplazo de una librería de datos en todas las aplicaciones —TanStack Query sigue ganando en caché, reintentos e invalidación—, pero para lecturas simples donde sobre todo quieres estados de carga dirigidos por Suspense, use() elimina una cantidad sorprendente de boilerplate y la máquina de estados de «definir cargando, definir datos, definir error» que causa la mayoría de los bugs de fetch.

Características concurrentes (React 18+)

React 18 introdujo el renderizado concurrente, y dos hooks lo exponen directamente: useTransition para actualizaciones que quieres marcar como no urgentes, y useDeferredValue para valores que deberían ir por detrás de la entrada que los produjo. Ambos resuelven el mismo problema de cara al usuario: la UI se mantiene responsiva mientras el trabajo costoso se renderiza en segundo plano.

useTransition es la versión explícita: envuelve la actualización de estado costosa en startTransition, y React mantiene la entrada responsiva mientras la transición se renderiza con prioridad menor.

import { useTransition, useState } from "react";

function SearchResults({ allItems }) {
  const [isPending, startTransition] = useTransition();
  const [query, setQuery] = useState("");
  const [filtered, setFiltered] = useState(allItems);

  function handleChange(e) {
    // Urgente: la propia entrada se actualiza al instante
    setQuery(e.target.value);
    // No urgente: el filtro costoso puede esperar
    startTransition(() => {
      const results = allItems.filter((item) =>
        item.name.toLowerCase().includes(e.target.value.toLowerCase())
      );
      setFiltered(results);
    });
  }

  return (
    <div>
      <input value={query} onChange={handleChange} />
      {isPending && <span>Filtering...</span>}
      <ul>
        {filtered.map((item) => (
          <li key={item.id}>{item.name}</li>
        ))}
      </ul>
    </div>
  );
}

useDeferredValue es la versión declarativa: pásale un valor que cambia a menudo —normalmente derivado de una entrada— y devuelve una versión que «va por detrás», renderizando primero con el valor antiguo y después re-renderizando con el nuevo cuando React tiene tiempo de sobra. Es ideal cuando el cálculo costoso está aguas abajo de un valor cuyo momento de actualización no controlas, como una query de búsqueda que se propaga por props hasta un componente de lista pesado.

import { useDeferredValue, useMemo } from "react";

function SearchResults({ query, items }) {
  const deferredQuery = useDeferredValue(query);

  const filtered = useMemo(() => {
    return items.filter((item) =>
      item.name.toLowerCase().includes(deferredQuery.toLowerCase())
    );
  }, [items, deferredQuery]);

  return (
    <ul>
      {filtered.map((item) => (
        <li key={item.id}>{item.name}</li>
      ))}
    </ul>
  );
}

La documentación de React cubre ambos hooks y cuándo elegir cada uno: useTransition cuando tú eres dueño de la actualización de estado, useDeferredValue cuando el valor llega como prop.

La advertencia honesta: estas funciones ayudan cuando el cuello de botella es la prioridad del renderizado, no su coste. Si un componente tarda 500ms en renderizarse, diferirlo mantiene la UI responsiva pero no lo hace más rápido: siguen haciendo falta virtualización o correcciones algorítmicas. Perfila primero; recurre a las transiciones cuando el flamegraph muestre renderizados costosos provocados por actualizaciones urgentes.

Core Web Vitals

Las tres métricas que Google usa para medir la experiencia del usuario real —LCP para carga, INP para interactividad, CLS para estabilidad visual— se cubren en profundidad en la receta de web performance, que incluye la configuración de la librería web-vitals y la recolección de datos de campo. La conclusión específica de React es corta: la mayoría de los fallos de CWV en aplicaciones React se remontan a una de tres cosas: un bundle inicial pesado que retrasa el LCP, long tasks de renderizados sin optimizar que dañan el INP, o dimensiones de imagen ausentes y carga de fuentes que causan CLS. Las técnicas de esta guía se mapean sobre esos tres grupos.

# Comprobación rápida en laboratorio durante el desarrollo
npx lighthouse https://localhost:3000 --view --preset=desktop

Trata Lighthouse como una prueba de humo, no como la línea de meta: las puntuaciones de laboratorio en tu máquina dicen poco sobre los datos de campo del percentil 75 sobre los que Google realmente posiciona. La referencia de vitals de web.dev tiene los umbrales actuales y la metodología de datos de campo.

Buenas prácticas

  • Perfila antes de optimizar — encuentra el cuello de botella real antes de recurrir a una técnica
  • Memoiza solo operaciones costosas — la sobre-memoización añade sobrecoste que supera el ahorro
  • Virtualiza listas de más de ~100–200 elementos — el número de nodos del DOM suele ser el primer muro que te encuentras
  • Divide rutas y funcionalidades pesadas — los usuarios solo pagan por el código que realmente ejecutan
  • Usa loading="lazy" bajo el pliegue y fetchpriority="high" en la imagen LCP
  • Define las dimensiones de las imágenes — previene el layout shift antes de que llegue la imagen
  • Divide el contexto por responsabilidad y memoiza los valores — o usa un store con selectores para el estado que cambia a menudo
  • Suscríbete de forma estrecha en la gestión de estado — selectores, no suscripciones a todo el store
  • Marca las actualizaciones no urgentes con useTransition — mantén las entradas responsivas durante renderizados costosos
  • Mide los datos de campo en producción — las puntuaciones de laboratorio y las de usuarios reales divergen más de lo que crees

Errores comunes

  • Memoizarlo todo — el sobrecoste de comparación supera el ahorro de renderizado en componentes baratos
  • No usar keys estables en listas — las keys de índice causan bugs al reordenar y derrotan silenciosamente la memoización
  • Props de objeto o array inline — una referencia nueva en cada renderizado rompe silenciosamente React.memo y los valores de contexto
  • Llamar a lazy() dentro del renderizado o de useMemo — crea un nuevo tipo de componente por renderizado y remonta el subárbol
  • Renderizar miles de nodos del DOM — sin virtualización, sin piedad del navegador
  • Suscribirse a stores completos o contextos demasiado amplios — cada cambio de estado ajeno re-renderiza el componente
  • Guardar estado derivado en useState — recalcula con useMemo o deriva durante el renderizado en su lugar
  • Confundir useMemo/useCallback con garantías semánticas — React puede descartar los valores memoizados
  • Optimizar sin línea base — no puedes demostrar una mejora que nunca mediste
  • Tratar las puntuaciones de Lighthouse como el objetivo — son un diagnóstico, no un KPI

Ver también

Preguntas frecuentes

¿Cuándo debería usar React.memo vs useMemo vs useCallback?

React.memo envuelve un componente para que se salte el re-renderizado cuando sus props no han cambiado. useMemo almacena en caché un valor calculado dentro de un componente, y useCallback almacena la referencia de una función por la misma razón —normalmente para mantener estable una prop de un hijo memoizado—. Ninguno hace el código más rápido por defecto; solo compensa cuando el profiling muestra un coste de renderizado real.

¿Cómo mido el rendimiento de React?

Empieza en desarrollo con el Profiler de React DevTools para ver qué componentes se renderizan y por qué, luego confírmalo en el navegador con la pestaña Performance de Chrome DevTools para los costes de layout y scripting. Para la verdad de producción, envía la librería web-vitals o tu herramienta de RUM y vigila LCP, INP y CLS tal como los experimentan los usuarios reales: esos son los datos sobre los que Google posiciona.

¿Sigue haciendo falta la memoización con el React Compiler?

Menos a menudo, pero no nunca. El compilador auto-memoiza lo que puede demostrar seguro, lo que cubre la mayoría de los casos rutinarios —pero no puede arreglar una mala arquitectura: contextos gigantes, valores que no puede verificar, renderizados costosos que siguen ocurriendo—. Mantén la memoización manual como herramienta puntual para los casos que el profiler señala, no como hábito por defecto.

¿Puede la división de código perjudicar el rendimiento?

Puede, si se exagera. Cada chunk dividido es una petición de red, así que dividir un componente necesario en el primer pintado añade latencia en lugar de quitarla. Divide en fronteras naturales —rutas, funcionalidades que los usuarios quizá nunca abran— y mantén el chunk inicial ligero. Una cascada de chunks diminutos es peor que un bundle un poco más grande.

¿Debería usar Server Components en lugar de optimización del lado del cliente?

Para aplicaciones en un framework que lo soporte como Next.js, los Server Components reducen el JavaScript que se envía y se re-renderiza en el cliente, lo que evita muchos de estos problemas en origen. No sustituyen la medición ni la virtualización —una lista enorme renderizada en el servidor sigue necesitando paginación o virtualización—, pero a menudo hacen menos necesaria la memoización. Consulta la guía de React Server Components para el panorama completo.