Home / Frontend / Paginación incremental en React: botón Cargar más con Hooks
Paginación incremental en React: botón Cargar más con Hooks

Paginación incremental en React: botón Cargar más con Hooks

17 November 2026 · 26 min de lectura ··

Qué vamos a construir y por qué importa

Casi todas las aplicaciones que muestran colecciones de datos terminan enfrentándose a la misma pregunta: cómo presentar cientos o miles de elementos sin saturar la red ni la pantalla. Las dos respuestas clásicas son la paginación numerada y el desplazamiento infinito, pero existe un término medio muy agradecido por los usuarios y sencillo de implementar: el botón «Cargar más». La lista empieza con un lote pequeño de elementos y, cuando la persona lo pide, se añade el siguiente lote al final, sin perder lo que ya estaba en pantalla.

En este tutorial construiremos desde cero una pequeña aplicación que muestra perfiles de personas ficticias obtenidos de una API pública de datos aleatorios. Cada pulsación del botón pedirá la siguiente página de resultados y la añadirá a la lista. Por el camino trabajaremos con los Hooks más importantes de React, con una petición fetch moderna, con estados de carga y de error, con la cancelación de peticiones obsoletas y con una extracción final a un Hook propio reutilizable.

El objetivo no es solo que el botón funcione, sino entender por qué cada decisión es la correcta: por qué se acumulan resultados en lugar de reemplazarlos, por qué conviene usar la forma funcional de los actualizadores de estado, qué papel juega el array de dependencias de useEffect y cómo evitar los bucles infinitos que tanto desconciertan al principio. Si estás empezando con el estado en componentes, te vendrá bien repasar antes Dominando el hook useState en React: guía completa 2026, porque aquí daremos por sentada la idea básica de estado local.

Al terminar tendrás una base reutilizable para catálogos de productos, listados de artículos, historiales de pedidos o cualquier otro listado remoto que crezca por tandas.

Requisitos y versiones que usaremos

Antes de escribir código conviene fijar el entorno. Este tutorial está pensado para el ecosistema actual de noviembre de 2026:

  • React en su rama 19, cuya última versión estable publicada en npm es la 19.3.x. Todo lo que verás funciona igual desde React 18, pero usamos la rama vigente.
  • Vite 8, la versión mayor estable desde marzo de 2026, como herramienta de desarrollo y empaquetado.
  • Node.js en una versión compatible con Vite 8, es decir, 20.19 o superior, o bien 22.12 o superior.
  • Un editor con soporte para JavaScript moderno y un navegador reciente.

Si quieres comprobar qué versión estable hay publicada en tu momento de lectura, puedes consultarlo directamente en el registro con estos comandos:

node --version
npm view react version
npm view vite version

Una nota importante sobre herramientas: durante años la forma habitual de arrancar un proyecto React era una utilidad de plantillas que hoy está descatalogada y ya no se recomienda para proyectos nuevos. La alternativa actual, rápida y mantenida, es Vite, y es la que emplearemos. Si no lo has usado antes, basta con seguir los pasos de la siguiente sección, que cubren lo necesario.

Tampoco instalaremos ninguna librería de peticiones HTTP. Durante mucho tiempo fue habitual añadir una dependencia externa para llamar a APIs, pero fetch está disponible en todos los navegadores modernos y cubre sobradamente nuestro caso, así que el proyecto tendrá cero dependencias adicionales.

Crear el proyecto con Vite

Abre una terminal y genera el proyecto con la plantilla de React. El nombre de la carpeta es libre; nosotros usaremos directorio-perfiles.

npm create vite@latest directorio-perfiles -- --template react
cd directorio-perfiles
npm install
npm run dev

El asistente puede hacerte alguna pregunta interactiva según la versión de la plantilla, por ejemplo si quieres activar utilidades experimentales. Para este tutorial puedes aceptar las opciones por defecto. Cuando el servidor de desarrollo arranque, verás en la consola una dirección local en la que se sirve la aplicación, normalmente en el puerto 5173.

La estructura inicial incluye varios archivos de ejemplo que no necesitamos. Vamos a limpiar y organizar la carpeta src de este modo:

directorio-perfiles/
├── index.html
├── package.json
├── vite.config.js
└── src/
    ├── main.jsx
    ├── App.jsx
    ├── estilos.css
    ├── hooks/
    │   └── usePerfiles.js
    └── componentes/
        ├── Cabecera.jsx
        ├── Perfil.jsx
        └── ListaPerfiles.jsx

Borra el contenido de la carpeta assets, el CSS de ejemplo y el contenido de App.jsx. Después, deja el punto de entrada así:

import { StrictMode } from "react";
import { createRoot } from "react-dom/client";
import App from "./App.jsx";
import "./estilos.css";

createRoot(document.getElementById("root")).render(
  <StrictMode>
    <App />
  </StrictMode>
);

Fíjate en StrictMode. En desarrollo, React monta, desmonta y vuelve a montar cada componente una vez para ayudarte a detectar efectos mal escritos. Más adelante veremos que esto hace que la petición inicial se dispare dos veces en desarrollo y cómo manejarlo con elegancia en lugar de desactivar la protección.

Conocer la API y el concepto de paginación

La fuente de datos será un servicio público que devuelve personas ficticias en formato JSON. Admite varios parámetros de consulta, y nos interesan tres:

  • results: cuántos perfiles devuelve cada petición.
  • page: el número de página que se solicita, empezando en 1.
  • seed: una cadena que fija la secuencia aleatoria, de modo que la misma semilla y la misma página devuelven siempre los mismos perfiles.

Ese último parámetro es muy útil para nosotros. Sin él, cada petición generaría gente distinta incluso para la misma página, y durante el desarrollo sería imposible reproducir comportamientos. Con una semilla fija, la página 2 siempre será la misma, igual que ocurriría con una base de datos real.

Una petición típica tendría esta forma:

GET https://randomuser.me/api/?results=8&page=2&seed=directorio

La respuesta es un objeto con una propiedad results, que es un array, y una propiedad info con metadatos. Cada elemento del array contiene, entre otros datos, esta información que usaremos:

{
  "name": { "first": "Lucía", "last": "Ferrer" },
  "email": "[email protected]",
  "location": { "country": "Spain" },
  "picture": { "large": "https://.../retrato.jpg" },
  "login": { "uuid": "3f0c1d2e-aaaa-bbbb-cccc-1234567890ab" }
}

El campo login.uuid es un identificador único, lo que lo convierte en una clave perfecta para el atributo key de React al pintar listas. Evita usar el índice del array como clave en listas que crecen o cambian, porque React perdería la correspondencia entre elementos y estado.

Componentes de presentación

Empezaremos por lo fácil: los componentes que solo pintan datos. Tener esta parte separada de la lógica de carga hace que el resto del tutorial sea más claro.

El primero es una cabecera sencilla:

export default function Cabecera() {
  return (
    <header className="cabecera">
      <h1>Directorio de perfiles</h1>
      <p>Explora la lista por tandas y carga más cuando quieras.</p>
    </header>
  );
}

El segundo representa una única persona. Recibe sus datos como propiedades individuales, lo que deja claro qué necesita realmente el componente:

export default function Perfil({ nombre, apellido, pais, correo, foto }) {
  return (
    <article className="perfil">
      <img src={foto} alt={`Retrato de ${nombre} ${apellido}`} width="96" height="96" />
      <div className="perfil-datos">
        <h2 className="perfil-nombre">
          {nombre} {apellido}
        </h2>
        <p>País: {pais}</p>
        <p>Correo: {correo}</p>
      </div>
    </article>
  );
}

Dos detalles de calidad. Primero, el texto alternativo de la imagen describe su contenido, algo imprescindible para la accesibilidad. Segundo, las dimensiones declaradas evitan saltos de diseño mientras las fotos se cargan, un problema que se nota mucho cuando vamos añadiendo tandas de elementos.

En un artículo con solo encabezados de segundo nivel como este, hemos usado h2 dentro de cada tarjeta por simplicidad; en una aplicación real ajusta la jerarquía de encabezados al contexto de tu página.

El tercero recorre el array y crea un Perfil por elemento:

import Perfil from "./Perfil.jsx";

export default function ListaPerfiles({ perfiles }) {
  return (
    <section className="lista">
      {perfiles.map((persona) => (
        <Perfil
          key={persona.login.uuid}
          nombre={persona.name.first}
          apellido={persona.name.last}
          pais={persona.location.country}
          correo={persona.email}
          foto={persona.picture.large}
        />
      ))}
    </section>
  );
}

Aquí hemos preferido pasar las propiedades una a una en lugar de esparcir el objeto completo. Es más verboso, pero documenta qué datos se usan y evita enviar propiedades innecesarias al componente hijo.

Primera versión: estado y efecto para la carga inicial

Ahora viene la parte central. Empezaremos escribiendo la lógica directamente en App.jsx para ver los Hooks en acción y, más adelante, la extraeremos a un Hook propio.

Necesitamos recordar cuatro cosas entre renderizados: la lista de perfiles acumulados, la página actual, si hay una petición en curso y el mensaje de error, si lo hay. Cada una será un estado independiente.

import { useEffect, useState } from "react";
import Cabecera from "./componentes/Cabecera.jsx";
import ListaPerfiles from "./componentes/ListaPerfiles.jsx";

const TAMANO_PAGINA = 8;

export default function App() {
  const [perfiles, setPerfiles] = useState([]);
  const [pagina, setPagina] = useState(1);
  const [cargando, setCargando] = useState(false);
  const [error, setError] = useState("");

  useEffect(() => {
    async function cargar() {
      setCargando(true);
      try {
        const url = `https://randomuser.me/api/?results=${TAMANO_PAGINA}&page=${pagina}&seed=directorio`;
        const respuesta = await fetch(url);
        if (!respuesta.ok) {
          throw new Error(`Respuesta inesperada: ${respuesta.status}`);
        }
        const datos = await respuesta.json();
        setPerfiles((anteriores) => [...anteriores, ...datos.results]);
        setError("");
      } catch (fallo) {
        setError("No pudimos cargar los perfiles. Inténtalo de nuevo.");
      } finally {
        setCargando(false);
      }
    }

    cargar();
  }, [pagina]);

  return (
    <main>
      <Cabecera />
      <ListaPerfiles perfiles={perfiles} />
      {error && <p role="alert" className="error">{error}</p>}
      <button onClick={() => setPagina((p) => p + 1)} disabled={cargando}>
        {cargando ? "Cargando..." : "Cargar más"}
      </button>
    </main>
  );
}

Este código ya funciona. Si lo ejecutas, verás ocho perfiles y, al pulsar el botón, otros ocho añadidos debajo. Pero hay mucho que desmenuzar, porque cada línea esconde una decisión.

Anatomía de la petición asíncrona

La función cargar está declarada dentro del efecto y es async. Esto es deliberado: la función que se pasa a useEffect no puede ser asíncrona directamente, porque una función async siempre devuelve una promesa y React espera que el efecto devuelva, como mucho, una función de limpieza. Declarar una función interna y llamarla es el patrón estándar.

Dentro usamos try, catch y finally, una estructura que lee mucho mejor que encadenar then, catch y finally sobre promesas. El orden de los acontecimientos es este:

  1. Se activa el indicador de carga antes de lanzar la petición.
  2. Se espera la respuesta y se comprueba respuesta.ok.
  3. Si todo va bien, se convierte el cuerpo a JSON y se actualiza la lista.
  4. Si algo falla, se guarda un mensaje legible para la persona usuaria.
  5. En cualquier caso, el bloque finally apaga el indicador de carga.

La comprobación de respuesta.ok merece atención. A diferencia de otras librerías, fetch no rechaza la promesa cuando el servidor responde con un código de error como 404 o 500; solo la rechaza ante fallos de red. Si no compruebas ok manualmente, un error del servidor pasaría como si fuera una respuesta válida y fallaría más tarde de una forma confusa al intentar leer datos.results.

El bloque finally también evita duplicar código. Sin él tendrías que escribir setCargando(false) tanto en la rama de éxito como en la de error, y es muy fácil olvidarse de una de las dos y dejar el botón bloqueado para siempre.

Acumular resultados con el actualizador funcional

La línea más importante de todo el tutorial es esta:

setPerfiles((anteriores) => [...anteriores, ...datos.results]);

Hay dos ideas en ella. La primera es que añadimos los nuevos resultados al final del array existente en lugar de reemplazarlo. Si escribieras setPerfiles(datos.results), cada pulsación borraría la tanda anterior y el usuario vería siempre una sola página, que es el comportamiento de una paginación clásica, no de un «cargar más».

La segunda idea es que pasamos una función en lugar de un valor. React llama a esa función con el valor más reciente del estado, y eso nos garantiza que trabajamos con datos actualizados aunque haya varias actualizaciones pendientes o el efecto haya capturado un valor antiguo. Es lo que se conoce como actualizador funcional, y es la clave para no depender del estado actual dentro del efecto.

Lo mismo se aplica al botón. Al escribir setPagina((p) => p + 1), el incremento se calcula sobre el valor más reciente. Si, en cambio, escribieras setPagina(pagina + 1), funcionaría en casos simples, pero dos clics muy rápidos dentro del mismo ciclo de renderizado podrían producir un único incremento, porque ambos leerían el mismo valor de pagina. Para profundizar en estos matices del estado, el artículo Ejemplos prácticos y conceptos esenciales en React 19 ofrece más casos.

El array de dependencias y el bucle infinito

El efecto termina con [pagina]. Ese array indica a React cuándo debe volver a ejecutarlo: la primera vez que el componente se monta y cada vez que pagina cambie entre renderizados. Así reproducimos un comportamiento sencillo: pulsar el botón cambia la página, el cambio provoca un renderizado, y el efecto detecta que la dependencia es distinta y lanza una nueva petición.

Es fácil equivocarse aquí, y vale la pena ver los tres errores típicos:

  • Omitir el array por completo. El efecto se ejecutaría después de cada renderizado, y como cada petición exitosa actualiza el estado y provoca otro renderizado, entrarías en un bucle infinito de peticiones.
  • Usar un array vacío. El efecto solo se ejecutaría al montar y, al cambiar de página, no ocurriría nada, aunque el botón incrementase el contador.
  • Añadir perfiles al array. Cada carga modifica perfiles, lo que dispararía el efecto de nuevo, que volvería a modificar perfiles, y así indefinidamente.

El tercer caso es el más traicionero, porque la regla de lint sobre dependencias de Hooks tiende a sugerir que añadas todo lo que se lee dentro del efecto. Si hubiéramos escrito setPerfiles([...perfiles, ...datos.results]), el efecto leería perfiles y el linter pediría incluirlo, provocando el bucle. La solución limpia es justo la que ya aplicamos: usar el actualizador funcional, de modo que el efecto ya no necesita leer perfiles y la dependencia desaparece sin romper nada.

Como regla general, cuando un efecto deba reaccionar a un cambio concreto, su array de dependencias contiene exactamente los valores que lo disparan, no el estado que él mismo modifica.

Cancelar peticiones obsoletas y manejar StrictMode

Nuestra versión actual tiene dos problemas sutiles que solo aparecen con cuidado.

El primero es el doble montaje de desarrollo que mencionamos. Con StrictMode activo, React ejecuta el efecto, lo limpia y lo ejecuta otra vez al montar el componente. Resultado: la página 1 se pide dos veces y, como acumulamos, ¡los ocho primeros perfiles aparecen duplicados! Si ves claves repetidas en la consola, esta es la causa.

El segundo es una condición de carrera. Imagina que la red va lenta, la persona pulsa el botón, el componente se desmonta o cambia otro parámetro, y una respuesta antigua llega después de otra más reciente. Sin control, esa respuesta tardía podría pisar o ensuciar el estado.

Ambos problemas se resuelven con la función de limpieza del efecto y un AbortController, el mecanismo estándar para cancelar un fetch:

useEffect(() => {
  const controlador = new AbortController();

  async function cargar() {
    setCargando(true);
    try {
      const url = `https://randomuser.me/api/?results=${TAMANO_PAGINA}&page=${pagina}&seed=directorio`;
      const respuesta = await fetch(url, { signal: controlador.signal });
      if (!respuesta.ok) {
        throw new Error(`Respuesta inesperada: ${respuesta.status}`);
      }
      const datos = await respuesta.json();
      setPerfiles((anteriores) => [...anteriores, ...datos.results]);
      setError("");
    } catch (fallo) {
      if (fallo.name === "AbortError") {
        return;
      }
      setError("No pudimos cargar los perfiles. Inténtalo de nuevo.");
    } finally {
      if (!controlador.signal.aborted) {
        setCargando(false);
      }
    }
  }

  cargar();

  return () => controlador.abort();
}, [pagina]);

Veamos qué sucede ahora. Cuando React limpia el primer montaje de StrictMode, llama a controlador.abort(). El fetch en curso se rechaza con un error llamado AbortError, que ignoramos explícitamente en el catch. El segundo montaje lanza una petición nueva que sí se completa y se añade una sola vez. En producción, donde no hay doble montaje, la limpieza solo actúa cuando la página cambia antes de que llegue la respuesta o cuando el componente se desmonta.

Fíjate también en que finally comprueba si la señal fue abortada antes de apagar el indicador de carga. Si no lo hicieras, una petición cancelada podría apagar el indicador que pertenece a la petición nueva, y el botón se habilitaría demasiado pronto.

Si prefieres no depender de esta técnica en proyectos pequeños, existe la alternativa de usar una bandera booleana local, pero AbortController tiene la ventaja de cancelar de verdad la petición de red y liberar recursos, no solo de ignorar el resultado.

Una mejor experiencia: estados de carga, vacío y fin de lista

Un botón «Cargar más» profesional comunica con claridad tres situaciones que nuestra primera versión ignora.

La primera es la carga inicial. Mientras no hay ningún perfil, mostrar un botón «Cargar más» tiene poco sentido; conviene un mensaje de espera. La segunda es el error: si falla la primera petición, la lista está vacía y la persona necesita una forma de reintentar. La tercera es el final de los datos: cuando el servidor ya no tiene más elementos, el botón debería desaparecer o desactivarse.

La API de nuestro ejemplo es prácticamente inagotable, así que simularemos un límite máximo de páginas para ver el patrón completo. Añade una constante y calcula un booleano derivado:

const TOTAL_PAGINAS = 5;

// dentro del componente
const hayMas = pagina < TOTAL_PAGINAS;

Observa que hayMas no es un estado, sino un valor calculado a partir del estado existente. Es un principio fundamental en React: no guardes en un estado algo que puedes deducir de otro, porque duplicar información abre la puerta a incoherencias. Después el renderizado puede ser así:

return (
  <main>
    <Cabecera />
    {perfiles.length === 0 && cargando && <p>Cargando perfiles...</p>}
    <ListaPerfiles perfiles={perfiles} />
    {error && (
      <p role="alert" className="error">
        {error}
      </p>
    )}
    {hayMas ? (
      <button onClick={() => setPagina((p) => p + 1)} disabled={cargando}>
        {cargando ? "Cargando..." : "Cargar más"}
      </button>
    ) : (
      <p>Has llegado al final de la lista.</p>
    )}
  </main>
);

Si la API real que uses devuelve el total de elementos o un indicador de página siguiente, calcula hayMas a partir de esos datos en lugar de una constante. Muchas APIs devuelven un campo con la cantidad total o un enlace a la siguiente página; aprovéchalo. Si no lo hacen, un truco habitual es pedir un elemento de más y, si llega, saber que existe otra página.

Además, el atributo disabled durante la carga evita pulsaciones repetidas que lanzarían páginas saltadas. Es una defensa simple, pero recuerda que no sustituye la validación del servidor.

Extraer la lógica a un Hook propio

Nuestro componente App ya mezcla presentación y lógica de datos. Cuando esto crece, la solución natural es un Hook personalizado: una función cuyo nombre empieza por use y que encapsula estado y efectos para poder reutilizarlos. Guarda esto en src/hooks/usePerfiles.js:

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

export function usePerfiles({ tamano = 8, totalPaginas = 5, semilla = "directorio" } = {}) {
  const [perfiles, setPerfiles] = useState([]);
  const [pagina, setPagina] = useState(1);
  const [cargando, setCargando] = useState(false);
  const [error, setError] = useState("");

  useEffect(() => {
    const controlador = new AbortController();

    async function cargar() {
      setCargando(true);
      try {
        const url = `https://randomuser.me/api/?results=${tamano}&page=${pagina}&seed=${semilla}`;
        const respuesta = await fetch(url, { signal: controlador.signal });
        if (!respuesta.ok) {
          throw new Error(`Respuesta inesperada: ${respuesta.status}`);
        }
        const datos = await respuesta.json();
        setPerfiles((anteriores) => [...anteriores, ...datos.results]);
        setError("");
      } catch (fallo) {
        if (fallo.name === "AbortError") {
          return;
        }
        setError("No pudimos cargar los perfiles. Inténtalo de nuevo.");
      } finally {
        if (!controlador.signal.aborted) {
          setCargando(false);
        }
      }
    }

    cargar();
    return () => controlador.abort();
  }, [pagina, tamano, semilla]);

  const cargarMas = useCallback(() => {
    setPagina((p) => p + 1);
  }, []);

  return {
    perfiles,
    cargando,
    error,
    hayMas: pagina < totalPaginas,
    cargarMas,
  };
}

Hay varios aspectos nuevos que merecen explicación. El Hook acepta opciones con valores por defecto, de modo que quien lo use puede cambiar el tamaño de lote sin tocar su interior. Esas opciones se añaden al array de dependencias porque el efecto las lee; si un valor se usa dentro del efecto, debe constar en el array. Con una semilla o tamaño distintos, el efecto se volvería a ejecutar, y en un caso real tendrías que decidir si reiniciar la lista en ese momento.

La función cargarMas se envuelve en useCallback para que su identidad sea estable entre renderizados. No es obligatorio en un ejemplo tan pequeño, pero si pasas esa función a un componente hijo memoizado, evitará renderizados innecesarios. No abuses de esta herramienta: úsala cuando haya una razón medible, no por costumbre.

Con el Hook creado, App.jsx queda reducido a lo esencial:

import Cabecera from "./componentes/Cabecera.jsx";
import ListaPerfiles from "./componentes/ListaPerfiles.jsx";
import { usePerfiles } from "./hooks/usePerfiles.js";

export default function App() {
  const { perfiles, cargando, error, hayMas, cargarMas } = usePerfiles();

  return (
    <main>
      <Cabecera />
      {perfiles.length === 0 && cargando && <p>Cargando perfiles...</p>}
      <ListaPerfiles perfiles={perfiles} />
      {error && (
        <p role="alert" className="error">
          {error}
        </p>
      )}
      {hayMas ? (
        <button onClick={cargarMas} disabled={cargando}>
          {cargando ? "Cargando..." : "Cargar más"}
        </button>
      ) : (
        <p>Has llegado al final de la lista.</p>
      )}
    </main>
  );
}

El resultado es un componente que describe qué se ve y un Hook que explica cómo se obtienen los datos. Si mañana quieres mostrar la misma lista en otra pantalla, o sustituir la API por la de tu propio servidor, solo tocas un archivo. Si necesitas que dos zonas de la interfaz compartan esos datos, tendrás que decidir en qué componente vive el estado, algo que se explica bien en Elevar el estado en React: cómo compartir datos entre componentes.

Estilos mínimos para una lista agradable

Un buen botón de carga adicional necesita una interfaz clara. Este CSS en src/estilos.css ofrece una cuadrícula adaptable y un botón con estados visibles, sin dependencias:

:root {
  font-family: system-ui, sans-serif;
  color: #1f2430;
  background: #f5f6fa;
}

body {
  margin: 0;
}

main {
  max-width: 960px;
  margin: 0 auto;
  padding: 2rem 1rem 4rem;
}

.cabecera {
  text-align: center;
  margin-bottom: 2rem;
}

.lista {
  display: grid;
  grid-template-columns: repeat(auto-fill, minmax(260px, 1fr));
  gap: 1rem;
}

.perfil {
  display: flex;
  gap: 1rem;
  align-items: center;
  padding: 1rem;
  background: #ffffff;
  border-radius: 12px;
  box-shadow: 0 1px 4px rgba(0, 0, 0, 0.08);
}

.perfil img {
  border-radius: 50%;
  object-fit: cover;
}

.perfil-nombre {
  margin: 0 0 0.25rem;
  font-size: 1.05rem;
}

.perfil-datos p {
  margin: 0;
  font-size: 0.9rem;
  overflow-wrap: anywhere;
}

button {
  display: block;
  margin: 2rem auto 0;
  padding: 0.75rem 1.75rem;
  border: 0;
  border-radius: 8px;
  background: #3b5bdb;
  color: #ffffff;
  font-size: 1rem;
  cursor: pointer;
}

button:disabled {
  opacity: 0.6;
  cursor: wait;
}

button:focus-visible {
  outline: 3px solid #91a7ff;
  outline-offset: 2px;
}

.error {
  color: #c92a2a;
  text-align: center;
}

La regla repeat(auto-fill, minmax(260px, 1fr)) hace que la cuadrícula ajuste el número de columnas al ancho disponible, sin consultas de medios. El estado :focus-visible es importante para quienes navegan con teclado, y el cursor wait comunica visualmente que hay una operación en curso.

Accesibilidad al añadir contenido dinámico

Cuando una lista crece por interacción, las personas que usan lector de pantalla necesitan saber que ha ocurrido algo. Si el botón añade perfiles y la voz sintética no dice nada, la acción parece no haber tenido efecto. Hay dos mejoras sencillas.

La primera es un mensaje en una región viva que anuncie el resultado sin robar el foco:

<p className="solo-lectores" aria-live="polite">
  {cargando ? "Cargando más perfiles" : `${perfiles.length} perfiles mostrados`}
</p>

Con la clase solo-lectores ocultas el texto visualmente pero lo mantienes disponible para tecnologías de apoyo:

.solo-lectores {
  position: absolute;
  width: 1px;
  height: 1px;
  overflow: hidden;
  clip-path: inset(50%);
  white-space: nowrap;
}

La segunda mejora es mantener el foco en un lugar coherente. El botón sigue en la misma posición del documento tras cada carga, porque los nuevos elementos se insertan por encima de él, así que el foco no se pierde. Pero si después de cargar quisieras llevar al usuario al primer elemento nuevo, tendrías que gestionar el foco manualmente con una referencia. Valora si de verdad aporta valor antes de añadir esa complejidad.

Tampoco olvides que un botón desactivado con disabled sale del orden de tabulación. En algunas situaciones es preferible usar aria-disabled y conservar el foco, pero para nuestro caso, con un texto que cambia a «Cargando…», la solución sencilla es suficiente.

Errores frecuentes y cómo diagnosticarlos

Este patrón es sencillo, pero genera síntomas muy característicos cuando algo falla. Esta es una guía de diagnóstico rápida.

  • Perfiles duplicados al arrancar: casi siempre es el doble montaje de StrictMode sin cancelación en la limpieza. Añade el AbortController o una comprobación equivalente.
  • Aviso de claves repetidas: ocurre cuando se acumulan los mismos elementos dos veces, o cuando se usa como clave un campo que no es único. Revisa que la clave provenga de un identificador estable.
  • El botón no hace nada: comprueba que el efecto tiene pagina en su array de dependencias y que el incremento se aplica realmente. Un array vacío es la causa más habitual.
  • Peticiones sin fin: el efecto no tiene array de dependencias o este incluye un estado que el propio efecto modifica.
  • La lista se reemplaza en vez de crecer: estás pasando el nuevo array directamente a setPerfiles en lugar de combinarlo con el anterior.
  • El botón queda bloqueado para siempre: falta el apagado de cargando en alguna rama, o el finally está condicionado a algo que nunca se cumple.
  • Error de red silencioso: no estás comprobando respuesta.ok y el servidor devuelve un código de error con un cuerpo que no esperas.

Una herramienta útil en todos los casos es la pestaña de red de las herramientas de desarrollo del navegador. Allí ves cuántas peticiones se lanzan, con qué parámetros y en qué orden, y puedes simular una conexión lenta o sin conexión para probar tus estados de carga y de error. Las extensiones de React para el navegador permiten, además, inspeccionar el estado de cada componente y comprobar que perfiles crece como esperas.

Rendimiento y límites de este enfoque

Acumular elementos sin fin tiene un coste. Cada tanda añade nodos al documento, y tras muchas pulsaciones la lista puede contener cientos o miles de tarjetas con imágenes. Esto repercute en memoria y en el tiempo de renderizado, sobre todo en dispositivos modestos.

Hay varias estrategias para mitigarlo. Puedes añadir loading="lazy" a las imágenes para que el navegador las descargue solo cuando se acercan a la ventana visible. Puedes aplicar React.memo al componente Perfil para que no se vuelva a renderizar cuando solo cambia la lista, ya que sus propiedades individuales no varían entre tandas. Y, si la lista llega a ser muy larga, la técnica más eficaz es la virtualización: renderizar únicamente las filas visibles. Es una complejidad que no merece la pena para decenas de elementos, pero sí para miles.

<img
  src={foto}
  alt={`Retrato de ${nombre} ${apellido}`}
  width="96"
  height="96"
  loading="lazy"
/>

Otro aspecto es la coherencia de los datos. Con paginación por número de página, si el servidor inserta o elimina elementos entre dos peticiones, puedes ver duplicados o saltarte alguno, porque los desplazamientos cambian. Las APIs más robustas usan paginación por cursor: en lugar de pedir la página 3, pides los elementos posteriores a un identificador concreto. Si controlas el backend, es la opción más fiable para listas que cambian con frecuencia.

Finalmente, ten en cuenta la caché. Si la persona navega a otra pantalla y vuelve, nuestro Hook volverá a pedir la primera página desde cero. Para aplicaciones con mucha navegación, conviene valorar una librería de gestión de datos remotos con caché e invalidación, pero entender primero el patrón manual, como acabamos de hacer, te permitirá usar esas herramientas con criterio.

Comparativa con otras formas de paginar

El botón «Cargar más» no es siempre la mejor elección. Conviene conocer sus alternativas para decidir con fundamento.

La paginación numerada es ideal cuando la persona necesita saltar a una posición concreta, compartir un enlace a una página o volver a un punto exacto. Tiene URLs estables, buen comportamiento con el botón «atrás» y un uso de memoria constante. Es la mejor opción para tablas de administración y resultados de búsqueda en los que se compara y se localiza.

El desplazamiento infinito carga automáticamente al acercarse al final. Resulta fluido para contenido de consumo continuo, como un flujo de publicaciones, pero tiene inconvenientes: dificulta llegar al pie de página, complica la accesibilidad con teclado y hace difícil recuperar la posición al volver. Se implementa con un observador de intersección que dispara la misma función cargarMas que ya tenemos, así que el Hook que hemos escrito te sirve igual.

El botón «Cargar más» se sitúa en el punto intermedio. Da control explícito a la persona, deja el pie de página accesible, es sencillo de hacer accesible y funciona bien en móviles. Su debilidad es que, igual que el desplazamiento infinito, no ofrece por sí mismo una URL con la posición. Si lo necesitas, puedes reflejar la página en la dirección con un parámetro de consulta, de modo que al recargar se recupere el estado.

Una regla práctica: si el usuario explora y descubre, prefiere «Cargar más» o desplazamiento infinito; si el usuario busca y compara, prefiere la paginación numerada.

Pruebas rápidas del comportamiento

Una vez terminado, merece la pena comprobar el comportamiento de forma sistemática. Aunque no vamos a montar un conjunto de pruebas automáticas completo, estos escenarios manuales cubren los casos críticos:

  1. Arranque limpio: deben aparecer ocho perfiles, sin duplicados, aunque StrictMode esté activo.
  2. Pulsaciones consecutivas: tras tres clics, la lista debe tener treinta y dos elementos, sin saltos de página.
  3. Red lenta: con la conexión limitada desde las herramientas de desarrollo, el botón debe mostrar «Cargando…» y permanecer desactivado.
  4. Sin conexión: al cortar la red, debe aparecer el mensaje de error y la lista previa debe conservarse intacta.
  5. Recuperación: tras restablecer la red, una nueva pulsación debe cargar la tanda correcta.
  6. Fin de lista: al llegar a la página máxima, el botón debe ser sustituido por el mensaje final.

Fíjate en el escenario cuatro. Cuando una petición falla en nuestro Hook, la página ya se había incrementado, así que al reintentar con el botón se pediría la página siguiente y se perdería la que falló. Es un detalle de diseño interesante. Una solución limpia es separar «página solicitada» de «página confirmada», avanzando esta última solo cuando la petición tiene éxito, o bien exponer una función reintentar que vuelva a lanzar la misma página. Para un ejemplo didáctico basta con conocer el matiz, pero en producción conviene resolverlo.

Ideas para ampliar el proyecto

Con la base funcionando, hay muchas extensiones que fortalecen lo aprendido:

  • Un campo de búsqueda que reinicie la lista y la página al cambiar el término, con una pequeña espera antes de lanzar la petición para no saturar al servidor.
  • Un filtro por nacionalidad o género, que obligue a decidir cuándo vaciar el array acumulado.
  • Un botón de «Volver arriba» que aparezca tras varias cargas.
  • Persistencia del estado en la dirección o en el almacenamiento de sesión para recuperar la posición.
  • Un esqueleto de carga que reserve el espacio de las tarjetas mientras llegan los datos.
  • Sustituir el estado múltiple por un reductor, usando useReducer, para agrupar las transiciones de carga, éxito y error en una sola función.

Esta última merece mención especial. Cuando varios estados cambian juntos con reglas claras, como «al empezar a cargar, limpia el error y activa la carga», un reductor expresa esas transiciones con más claridad y reduce la posibilidad de estados imposibles, como estar cargando y mostrar un error a la vez.

Conclusiones

Hemos construido una lista con carga incremental que funciona de forma robusta, partiendo de un proyecto nuevo con Vite 8 y React 19. Más importante que el resultado visual es el conjunto de ideas que sostienen el patrón.

Primero, el estado se divide en piezas pequeñas y significativas: elementos acumulados, página, indicador de carga y error. Segundo, los nuevos resultados se combinan con los anteriores mediante actualizadores funcionales, lo que evita datos obsoletos y mantiene el efecto libre de dependencias problemáticas. Tercero, el array de dependencias de useEffect contiene solo el valor que debe disparar la carga, y esa disciplina elimina el temido bucle infinito. Cuarto, un AbortController en la función de limpieza convierte en inofensivo el doble montaje de desarrollo y protege frente a respuestas tardías.

También vimos cómo comprobar respuesta.ok, cómo apagar la carga siempre desde un finally, cómo derivar valores como hayMas en lugar de guardarlos, cómo extraer todo a un Hook propio para separar lógica y presentación, y cómo cuidar la accesibilidad con regiones vivas y estados de foco visibles. Finalmente, comparamos el enfoque con la paginación numerada y el desplazamiento infinito para que elijas la opción adecuada a cada contexto.

El siguiente paso natural es probarlo con una API real tuya, añadir búsqueda y filtros, y valorar useReducer o una librería de datos remotos cuando el proyecto lo pida. Con estos fundamentos, el botón «Cargar más» deja de ser un truco aislado y se convierte en una pieza de diseño que sabes mantener, depurar y ampliar.