Inicio / Artículos

Ocho soluciones para el renderizado en React que reducen las actualizaciones en un 80% sin necesidad de reescribir el código.

Primero el perfil, y luego aplicar memo, useMemo, useCallback, transiciones, virtualización de listas, división de código y selectores específicos para acelerar un gran panel de control de React.

Editor: REACTAPP.TOP5 min de lectura1245 palabras

Fuentes: How I Optimized a Slow React App Without Rewriting It

Imagínese una demostración de panel de control en la que cada clic en un filtro congela la pantalla durante un segundo entero. El código está bien organizado y sigue las mejores prácticas, pero sigue siendo increíblemente lento. La base de código cuenta con 50,000 líneas y nadie tiene presupuesto para reconstruirla, por lo que la única opción es hacer que el renderizado sea más eficiente sin cambiar las funcionalidades. Los pasos a continuación siguen ese enfoque, y en el escenario de ejemplo reducen las actualizaciones de renderizado en aproximadamente un 80%.

Mida antes de tocar nada

Optimizar a ciegas es una pérdida de tiempo, por eso lo primero es realizar un análisis. Tres herramientas se encargan de la mayor parte del trabajo:

  • El Profilador de React DevTools, para registrar las interacciones y analizar el gráfico de llama para identificar qué componentes se vuelven a renderizar innecesariamente.
  • why-did-you-render, una biblioteca que registra las actualizaciones de renderizado evitables.
  • La pestaña de Rendimiento de Chrome DevTools, para conocer los tiempos reales de cada frame.

El patrón típico es fácil de detectar. Un padre actualiza su estado y todos los hijos que se encuentran debajo se vuelven a renderizar, independientemente de si utilizan o no los datos modificados. En una aplicación pequeña eso apenas importa. Pero en un panel de control con cientos de componentes, un cambio de estado en la parte superior puede desencadenar una cascada.

Memorizar componentes con React.memo

Cuando un componente recibe las mismas props, debería producir el mismo resultado, y React.memo almacena ese resultado en caché. El enfoque sensato es comenzar con los componentes puros que aparecen con mayor frecuencia en la lista de re-renderización del perfilador, en lugar de envolver todo.

const ExpensiveComponent = React.memo(({ data, onUpdate }) => {
  // Component logic
});

Un problema: React.memo compara los props de forma superficial. La función pasada como prop se recrea en cada renderizado, por lo que la memorización nunca se activa. useCallback soluciona ese caso. Una vez que la memorización se aplica donde realmente importa, los componentes que antes se volvían a renderizar con cada cambio de estado ahora lo hacen solo cuando cambian sus propios props.

Un consejo: no todos los componentes se benefician. Solo aquellos que se vuelven a renderizar con frecuencia usando los mismos props obtienen algún beneficio. Memorizar todo puede ser perjudicial, ya que almacenar resultados anteriores consume memoria.

useMemo y useCallback

React.memo evita que los componentes se vuelvan a renderizar. useMemo y useCallback evitan que se realice trabajo repetido dentro de ellos.

Tomemos un componente que calcula estadísticas agregadas a partir de un arreglo grande. Si se ejecuta en cada renderizado, incluidos aquellos en los que los datos no han cambiado, es un desperdicio. Al envolverlo en useMemo con los datos como dependencia, solo se volverá a ejecutar cuando los datos sí cambien:

const computedStats = useMemo(() => {
  return expensiveAggregation(data);
}, [data]);

useCallback resuelve un problema diferente. Los manejadores de eventos pasados a los hijos reciben una identidad nueva en cada renderizado, lo cual anula la comparación superficial que se realiza dentro de React.memo. Al envolver el manejador, se mantiene estable su referencia:

const handleUpdate = useCallback((id) => {
  updateItem(id);
}, []);

El efecto es que los cálculos costosos dejan de repetirse, los niños dejan de volver a renderizar sin motivo y la interfaz parece más ágil.

Mantén la respuesta al teclado con useTransition

Un clic debería generar una reacción inmediata, pero una actualización de estado intensiva puede congelar el navegador hasta que finalice. Imagina un cuadro de búsqueda que filtra una lista de 10,000 elementos: sin ayuda, cada tecla presionada bloquea la pantalla durante cientos de milisegundos.

useTransition marca la actualización como de baja prioridad, de modo que React mantiene la interfaz activa mientras el trabajo intensivo se realiza en segundo plano:

const [isPending, startTransition] = useTransition();
const handleSearch = (term) => {
  startTransition(() => {
    setSearchTerm(term);
    // Filtering happens in the background
  });
};

La filtración sigue ocurriendo, pero no a costa de tener que escribir. La diferencia se hace evidente en cuanto alguien utiliza el cuadro de texto.

Valores de retraso con useDeferredValue

useDeferredValue es similar a useTransition, pero se aplica a un valor en lugar de a una actualización de estado. Indica a React que el valor puede retrasarse cuando hay algo más urgente que atender.

Imagínese un gráfico en tiempo real que se vuelve a renderizar cada vez que cambian los datos. Su renderizado es costoso y bloquea otras actualizaciones. Al retrasar el valor que recibe, React puede dibujar primero las partes más urgentes:

const deferredData = useDeferredValue(data);
// Chart receives deferredData and updates only when React has idle time

Los gráficos y las visualizaciones dejan de bloquear la interacción, y la aplicación sigue funcionando sin problemas incluso con grandes conjuntos de datos.

Virtualizar listas largas

Un usuario solo ve una pequeña parte de la lista en cualquier momento, por lo que renderizarla completa desperdicia recursos. Una tabla con 500 filas, todas montadas como nodos DOM en cada actualización, es un buen ejemplo. Sustituir un map() simple por react-window, que solo renderiza las filas visibles, cambia eso:

import { FixedSizeList } from 'react-window';
const Row = ({ index, style }) => (
  <div style={style}>
    {data[index].name}
  </div>
);
<FixedSizeList
  height={400}
  itemCount={data.length}
  itemSize={35}
  width="100%"
>
  {Row}
</FixedSizeList>

En el ejemplo, la tabla mostró unas 20 filas en lugar de 500. El uso de memoria disminuyó, el desplazamiento se suavizó y la página se cargó más rápido.

Dividir el paquete por ruta

Enviar toda la aplicación al cargarla por primera vez es otro error común. Si las vistas del panel de control, las analíticas, la configuración y los informes se compilan en un único archivo de JavaScript, la primera carga es lenta. lazy y Suspense de React dividen el paquete por ruta, de modo que cada vista se carga cuando el usuario navega a ella:

const Dashboard = lazy(() => import('./views/Dashboard'));
const Analytics = lazy(() => import('./views/Analytics'));
function App() {
  return (
    <Suspense fallback={<Loading />}>
      <Routes>
        <Route path="/" element={<Dashboard />} />
        <Route path="/analytics" element={<Analytics />} />
      </Routes>
    </Suspense>
  );
}

En este escenario, el paquete inicial pasó de 2,5 MB a 800 KB, y la primera carga mejoró notablemente.

Reduce los selectores de estado

Con Redux o Zustand, los componentes suelen seleccionar más estado del necesario. Si un componente raíz obtiene todo el almacén mediante useSelector, cualquier cambio en el almacén hace que se vuelva a renderizar. La solución es seleccionar solo las partes del estado que utiliza cada componente y memorizar los datos derivados con createSelector de Redux Toolkit:

import { createSelector } from '@reduxjs/toolkit';
const selectFilteredData = createSelector(
  (state) => state.items,
  (state) => state.filterTerm,
  (items, term) => items.filter(item =>
    item.name.toLowerCase().includes(term.toLowerCase())
  )
);
// In component:
const filteredData = useSelector(selectFilteredData);

Ahora los componentes se vuelven a renderizar solo cuando cambian los datos que realmente leen, y la cascada de actualizaciones cesa.

Antes y después

Métrica Antes Después
Media de re-renderizaciones por interacción 47 9
Tiempo hasta la interactividad 2.3 s 1.1 s
Pérdidas de fotogramas durante las animaciones Frecuentes Raras

Eso representa aproximadamente un 80% menos de re-renderizaciones, con la misma base de código y las mismas funciones.

Lo que esto demuestra

Acelerar una aplicación React se trata principalmente de comprender el problema, no de reescribirlo. El perfilador determina dónde buscar, de modo que el esfuerzo no se dirige a componentes aleatorios. Cada cambio aborda un problema específico y tiene un efecto medible; la mayoría toma media hora o menos. Se trata de mejoras precisas, no de reformas arquitectónicas a gran escala.

En resumen, la caja de herramientas incluye React.memo para componentes puros, useMemo para cálculos intensivos, useCallback para manejadores estables, los dos hooks concurrentes para tareas que pueden esperar, react-window para listas largas, carga diferida para rutas y selectores precisos para el estado del almacén.

Al aplicar estos patrones uno por uno y de manera constante, se convierte una aplicación lenta en una que parece responder al instante. Comience con el perfilador de DevTools, encuentre el cuello de botella más grande y resúltelo primero.

Leer más