# Hice las listas de React Native 8000 veces más rápidas

By Tarik Pinarci (https://tarikpinarci.com). Published 2026-06-20. Canonical: https://tarikpinarci.com/es/blog/improving-flatlist-performance-in-react-native

Sí, has leído bien: 8000 veces más rápidas.

No en el sentido de "toda tu app es ahora 8000 veces más rápida, ve a comprarte un yate". Por desgracia.

Y sí, ya sé que el momento tiene gracia.

Vivimos en una época en la que las noticias de IA van tan rápido que algo como [Claude Fable 5 puede lanzarse y quedar suspendido unos días después](https://www.anthropic.com/news/claude-fable-5-mythos-5). La gente discute sobre modelos casi AGI, controles de exportación, agentes que hacen proyectos enteros, todo eso.

Y aquí estoy yo, hablando de hacer más rápidas las listas de React Native.

Suena un poco raro cuando pones esas dos cosas una al lado de la otra. Lo entiendo.

Pero este tipo de trabajo me sigue pareciendo emocionante. Quizá "invento" sea una palabra demasiado grande, pero mejorar un framework que usan miles de apps sigue teniendo sentido para mí. No todo lo útil tiene que parecer ciencia ficción. A veces se trata solo de quitar trabajo desperdiciado de un camino que casi todas las apps móviles recorren.

La mejora está dentro de un camino concreto de las listas de React Native: el trabajo de la ventana de render que decide qué celdas deben existir en este momento. En ese benchmark, el camino anterior podía desperdiciar segundos con listas enormes, y el nuevo lo reduce a unos pocos milisegundos.

La mayor parte del tiempo estamos del lado de la app. Usamos `FlatList`, `SectionList`, navegación, animaciones, librerías de estado y todo lo habitual. Nos quejamos del rendimiento, probamos algunas props, añadimos `memo`, quizá `getItemLayout`, y seguimos con nuestra vida.

Pero a veces el problema real está una capa por debajo del código de la app.

Eso es lo que pasó aquí.

Contribuí con una mejora de rendimiento a `react/react-native`, fusionada como [PR #57210](https://github.com/react/react-native/pull/57210). El cambio elimina trabajo innecesario de búsqueda de sticky headers en el camino de creación de la máscara de render que usa `VirtualizedList`.

<figure style="max-width:720px; margin:24px auto 30px;">
  <img
    src="/images/blog/react-native-merged-proof/flatlist-merged.jpg"
    alt="Línea de tiempo de GitHub que muestra el pull request de rendimiento de FlatList fusionado en React Native"
    style="width:100%; border-radius:14px; border:1px solid rgba(255,255,255,0.12);"
  />
  <figcaption style="margin-top:8px; text-align:center; font-size:0.9rem; color:#9ca3af;">Fusionado en React Native. Todavía me parece un poco irreal.</figcaption>
</figure>

En palabras normales: React Native a veces buscaba sticky headers incluso cuando la lista no tenía ninguno.

Un momento clásico de la informática.

> Lista: "No tengo sticky headers".
>
> React Native: "Genial, déjame recorrer hacia atrás para encontrar uno".

Lo bueno es que este camino es compartido. Así que la mejora afecta a:

- `VirtualizedList`
- `FlatList`
- `VirtualizedSectionList`
- `SectionList`

Y sí, el uso normal de `FlatList` puede beneficiarse aunque no uses sticky headers en absoluto.

### Qué mejora realmente

Antes de entrar en el código, vale la pena aclarar de qué tipo de rendimiento hablamos.

La mejora está en el trabajo de JavaScript que hace React Native antes de decidir qué filas deben renderizarse.

`FlatList` mantiene una ventana de render. Mientras haces scroll, saltas, montas cerca de un índice inicial o te mueves por una lista grande, React Native tiene que decidir qué celdas renderizar y qué partes pueden quedarse como espaciadores.

Esa decisión pasa por `VirtualizedList._createRenderMask`.

Así que la mejora es:

- menos trabajo de JS durante las actualizaciones de la ventana de la lista
- menos trabajo al saltar cerca del final de una lista enorme
- menos lógica innecesaria de sticky headers en listas que no los tienen
- decisiones más rápidas antes de que la lista actualice lo que debe estar en pantalla

En términos de una app normal, esto ayuda a la parte de `FlatList` que decide "¿qué filas deberían existir ahora mismo?".

En listas muy grandes, sobre todo cerca del final, esa pequeña decisión interna puede convertirse en un coste real.

Eliminar ese coste abarata mucho el camino de actualización de la ventana de render.

### Lo que noté

`FlatList` es uno de esos componentes que casi todas las apps de React Native usan en algún momento.

Desde fuera parece simple:

```tsx
<FlatList data={items} renderItem={renderItem} />
```

Pero por debajo pasa por `VirtualizedList`.

`VirtualizedList` no renderiza toda la fuente de datos. Si tienes 100k filas, no pone 100k filas en pantalla como un soldado valiente pero condenado. Mantiene una ventana de render y usa una máscara de render para decidir qué celdas deben existir en este momento.

Eso está bien.

El problema estaba dentro del paso de creación de la máscara de render.

React Native también soporta sticky headers. Los sticky headers son especiales porque el elemento fijo puede estar fuera del viewport normal, pero aun así tiene que seguir renderizado porque visualmente está pegado arriba.

Así que React Native necesita una lógica como esta:

"Encuentra el sticky header más cercano antes del viewport y mantenlo renderizado."

Esa lógica es correcta.

Lo molesto era que la búsqueda podía ejecutarse igualmente cuando no había sticky headers.

### El camino anterior

Antes de este cambio, `VirtualizedList._createRenderMask` construía un set a partir de `stickyHeaderIndices` y llamaba a la función auxiliar de sticky headers.

La versión simplificada era así:

```js
const stickyIndicesSet = new Set(props.stickyHeaderIndices);
VirtualizedList._ensureClosestStickyHeader(
  props,
  stickyIndicesSet,
  renderMask,
  cellsAroundViewport.first,
);
```

Luego la función auxiliar recorría hacia atrás desde la primera celda visible:

```js
for (let itemIdx = cellIdx - 1; itemIdx >= 0; itemIdx--) {
  if (stickyIndicesSet.has(itemIdx + stickyOffset)) {
    renderMask.addCells({first: itemIdx, last: itemIdx});
    break;
  }
}
```

En una lista pequeña, da igual.

En una lista muy grande, se vuelve doloroso. Si el viewport está cerca del final de una lista de 1 millón de filas y no hay sticky headers, la función auxiliar puede recorrer hacia atrás casi toda la lista.

Básicamente es hacer una gran búsqueda para no encontrar nada.

No es mi pasatiempo favorito.

![](https://media.giphy.com/media/FASybzL1ElrxpT2rTq/giphy.gif)

### Por qué afecta a FlatList

Esta parte es fácil de pasar por alto.

No necesitas usar `VirtualizedList` directamente. `FlatList` está construido sobre él.

Así que un código como este:

```tsx
<FlatList
  data={bigData}
  renderItem={renderItem}
/>
```

sigue pasando por `VirtualizedList._createRenderMask`.

Antes del cambio, una lista normal sin `stickyHeaderIndices` podía seguir pagando el trabajo de búsqueda de sticky headers.

Después del cambio, React Native comprueba si de verdad existen sticky headers antes de hacer ese trabajo.

Tecnología muy avanzada: comprobar si algo existe antes de buscarlo.

### El cambio

La primera parte es la importante para el uso normal de `FlatList` sin sticky headers.

```js
const stickyHeaderIndices = props.stickyHeaderIndices;
if (stickyHeaderIndices != null && stickyHeaderIndices.length > 0) {
  VirtualizedList._ensureClosestStickyHeader(
    props,
    stickyHeaderIndices,
    renderMask,
    cellsAroundViewport.first,
  );
}
```

Si no hay sticky headers, nos saltamos la función auxiliar.

La segunda parte también mejora el caso con sticky headers.

En lugar de recorrer hacia atrás los índices de los elementos, la función auxiliar revisa los índices de sticky headers configurados y encuentra el sticky header válido más cercano antes del viewport.

```js
const stickyOffset = props.ListHeaderComponent ? 1 : 0;
const targetStickyIndex = cellIdx + stickyOffset;
let closestStickyIndex = null;

for (let itemIdx = 0; itemIdx < stickyHeaderIndices.length; itemIdx++) {
  const stickyIndex = stickyHeaderIndices[itemIdx];
  if (
    Number.isInteger(stickyIndex) &&
    stickyIndex < targetStickyIndex &&
    stickyIndex >= stickyOffset &&
    (closestStickyIndex == null || stickyIndex > closestStickyIndex)
  ) {
    closestStickyIndex = stickyIndex;
  }
}

if (closestStickyIndex != null) {
  const itemIdx = closestStickyIndex - stickyOffset;
  renderMask.addCells({first: itemIdx, last: itemIdx});
}
```

Así que el coste pasa de:

"¿A qué distancia estamos del inicio de la lista?"

a:

"¿Cuántos sticky headers hay configurados?"

Esa es una pregunta mucho mejor.

### Mantener el mismo comportamiento

Esta es la parte que hace que los cambios pequeños en un framework sean menos pequeños de lo que parecen.

No puedes simplemente optimizar y esperar que todo vaya bien. `stickyHeaderIndices` puede no estar ordenado. Puede contener valores duplicados. Puede contener valores inválidos. Puede haber un `ListHeaderComponent`, que desplaza el índice en uno.

Todo eso tiene que seguir funcionando.

Las pruebas cubren casos como:

- sin `stickyHeaderIndices`
- `stickyHeaderIndices` vacío
- índices de sticky headers sin ordenar
- índices de sticky headers duplicados
- valores negativos
- valores fraccionarios
- valores posteriores al viewport
- manejo del desplazamiento de `ListHeaderComponent`

Ese último es importante. Los índices de sticky headers se basan en los índices de los hijos del `ScrollView` subyacente. Cuando existe un encabezado de lista, el índice de elemento `0` ya no es el índice de hijo `0`.

A los pequeños errores de desfase por uno les encanta esta zona. Viven ahí sin pagar alquiler.

### Resultados del benchmark

Medí el camino de `VirtualizedList._createRenderMask` directamente con Fantom Hermes, usando 100 muestras por caso.

Este benchmark se centra en el trabajo de decisión de la ventana de render dentro de `VirtualizedList`.

Así que no, esto no significa que cada `FlatList` de cada app de repente haga scroll 8000 veces más rápido. Ojalá. Ya sería insoportable hablando de ello.

Significa que este camino interno concreto de ventanas de lista se volvió muchísimo más barato. Y cuando el benchmark pasa de segundos de trabajo desperdiciado a unos pocos milisegundos, sigue siendo una mejora muy real.

### Prueba en el simulador

También hice una pequeña app de React Native en flujo bare para comparar ambas implementaciones en el simulador de iOS.

La misma app. La misma `FlatList` de `1m` filas. La misma configuración `no sticky headers`.

La única diferencia es la implementación de `VirtualizedList` instalada. Son grabaciones reales del simulador dentro de los marcos del teléfono, no capturas estáticas de maquetas. Dejé los controles del video visibles a propósito, y el pulso del cursor marca el toque en el botón del benchmark.

El benchmark y las pruebas de comportamiento también están en el PR fusionado de React Native:

- [Prueba de benchmark de Fantom](https://github.com/react/react-native/blob/6b3a15b2c0eca3647e4648d4b68bcccd4336d42f/packages/react-native/Libraries/Lists/__tests__/VirtualizedList-stickyHeaders-benchmark-itest.js)
- [Pruebas de comportamiento de VirtualizedList](https://github.com/react/react-native/blob/6b3a15b2c0eca3647e4648d4b68bcccd4336d42f/packages/virtualized-lists/Lists/__tests__/VirtualizedList-test.js)
- [PR #57210 fusionado](https://github.com/react/react-native/pull/57210)

<div style="display:grid; grid-template-columns: repeat(auto-fit, minmax(260px, 1fr)); gap: 36px; margin: 32px 0 42px; align-items:start; perspective:1400px;">
  <figure style="margin:0; transform:rotateY(10deg) rotateX(3deg); transform-style:preserve-3d;">
    <figcaption style="font-weight:700; color:#fca5a5; margin-bottom:14px; text-align:center;">Antes</figcaption>
    <div style="position:relative; max-width:330px; margin:0 auto; aspect-ratio:985/2008; filter:drop-shadow(32px 34px 46px rgba(0,0,0,0.58));">
    <div style="position:absolute; z-index:3; left:10%; top:5.5%; padding:5px 9px; border-radius:999px; background:rgba(0,0,0,0.68); border:1px solid rgba(255,255,255,0.16); color:#f8fafc; font-size:0.72rem; font-weight:700; pointer-events:none;">▶ video del simulador</div>
    <video
      data-autoplay="viewport"
      autoplay
      controls
      playsinline
      muted
      loop
      preload="metadata"
      style="position:absolute; left:5.19%; top:2.17%; width:89.93%; height:95.66%; border-radius:8.8%/4.1%; object-fit:cover; background:#05080f;"
      src="/videos/blog/flatlist-performance/before-release-simplified.mp4"
    >
      Tu navegador no admite la etiqueta de video.
    </video>
    <div class="flatlist-video-cursor flatlist-video-cursor-before" aria-hidden="true"></div>
    <img
      src="/images/blog/device-frames/iphone-14-pro-black.png"
      alt=""
      loading="lazy"
      style="position:absolute; inset:0; width:100%; height:100%; pointer-events:none;"
    />
    </div>
  </figure>
  <figure style="margin:0; transform:rotateY(-10deg) rotateX(3deg); transform-style:preserve-3d;">
    <figcaption style="font-weight:700; color:#86efac; margin-bottom:14px; text-align:center;">Después</figcaption>
    <div style="position:relative; max-width:330px; margin:0 auto; aspect-ratio:985/2008; filter:drop-shadow(-32px 34px 46px rgba(0,0,0,0.58));">
    <div style="position:absolute; z-index:3; left:10%; top:5.5%; padding:5px 9px; border-radius:999px; background:rgba(0,0,0,0.68); border:1px solid rgba(255,255,255,0.16); color:#f8fafc; font-size:0.72rem; font-weight:700; pointer-events:none;">▶ video del simulador</div>
    <video
      data-autoplay="viewport"
      autoplay
      controls
      playsinline
      muted
      loop
      preload="metadata"
      style="position:absolute; left:5.19%; top:2.17%; width:89.93%; height:95.66%; border-radius:8.8%/4.1%; object-fit:cover; background:#05080f;"
      src="/videos/blog/flatlist-performance/after-release-simplified.mp4"
    >
      Tu navegador no admite la etiqueta de video.
    </video>
    <div class="flatlist-video-cursor flatlist-video-cursor-after" aria-hidden="true"></div>
    <img
      src="/images/blog/device-frames/iphone-14-pro-black.png"
      alt=""
      loading="lazy"
      style="position:absolute; inset:0; width:100%; height:100%; pointer-events:none;"
    />
    </div>
  </figure>
</div>

En la demo del simulador, el camino anterior crece con el tamaño de la lista. Para 1k actualizaciones de la ventana de render, se ve así:

- `50k rows`: unos `1.92 s` en total (`1.9196 ms / call`)
- `500k rows`: unos `18.78 s` en total (`18.78 ms / call`)
- `1m rows`: unos `38.40 s` en total (`38.40 ms / call`)

Con el camino optimizado, la misma demo se mantiene prácticamente plana:

- `50k rows`: unos `3.74 ms` en total (`0.0037 ms / call`)
- `500k rows`: unos `3.67 ms` en total (`0.0037 ms / call`)
- `1m rows`: unos `3.73 ms` en total (`0.0037 ms / call`)

Los valores por llamada están por debajo de 1 segundo, así que se muestran en milisegundos. Para 1,000 actualizaciones de la máscara de render, los valores por encima de 1 segundo se muestran en segundos.

| Caso | Una actualización antes | Una actualización después | Aceleración | 1,000 actualizaciones antes | 1,000 actualizaciones después |
| --- | ---: | ---: | ---: | ---: | ---: |
| 100k filas, sin sticky headers | 2.664 ms | 0.0034 ms | 780x | 2.66 s | 3.42 ms |
| 100k filas, sticky headers vacíos | 2.632 ms | 0.0033 ms | 800x | 2.63 s | 3.29 ms |
| 100k filas, un sticky header arriba | 2.705 ms | 0.0054 ms | 499x | 2.71 s | 5.42 ms |
| 250k filas, sin sticky headers | 6.543 ms | 0.0035 ms | 1,892x | 6.54 s | 3.46 ms |
| 250k filas, sticky headers vacíos | 6.579 ms | 0.0033 ms | 2,024x | 6.58 s | 3.25 ms |
| 250k filas, un sticky header arriba | 6.796 ms | 0.0053 ms | 1,294x | 6.80 s | 5.25 ms |
| 500k filas, sin sticky headers | 13.173 ms | 0.0033 ms | 4,002x | 13.17 s | 3.29 ms |
| 500k filas, sticky headers vacíos | 13.073 ms | 0.0033 ms | 3,997x | 13.07 s | 3.27 ms |
| 500k filas, un sticky header arriba | 13.444 ms | 0.0054 ms | 2,511x | 13.44 s | 5.35 ms |
| 750k filas, sin sticky headers | 19.524 ms | 0.0033 ms | 6,008x | 19.52 s | 3.25 ms |
| 750k filas, sticky headers vacíos | 19.572 ms | 0.0033 ms | 6,022x | 19.57 s | 3.25 ms |
| 750k filas, un sticky header arriba | 20.304 ms | 0.0054 ms | 3,778x | 20.30 s | 5.37 ms |
| 1m filas, sin sticky headers | 26.190 ms | 0.0033 ms | 8,058x | 26.19 s | 3.25 ms |
| 1m filas, sticky headers vacíos | 26.039 ms | 0.0033 ms | 8,012x | 26.04 s | 3.25 ms |
| 1m filas, un sticky header arriba | 26.855 ms | 0.0053 ms | 5,075x | 26.86 s | 5.29 ms |

La columna de 1,000 actualizaciones hace que la diferencia se sienta más.

Con 1 millón de filas, el camino anterior sin sticky headers pasa unos 26 segundos en esta función auxiliar para 1,000 actualizaciones de la máscara de render.

Después del cambio, el mismo caso ronda los 3.25 ms.

Es tiempo eliminado de un camino compartido de listas antes de que React Native decida qué celdas renderizar.

### Plan de pruebas

Quería que esto fuera aburrido en el mejor sentido: el mismo comportamiento, menos trabajo.

Así que la contribución incluyó pruebas de comportamiento y cobertura de benchmark.

Los comandos principales fueron:

```sh
yarn jest packages/virtualized-lists/Lists/__tests__/VirtualizedList-test.js packages/virtualized-lists/Lists/__tests__/VirtualizedSectionList-test.js packages/react-native/Libraries/Lists/__tests__/FlatList-test.js --runInBand
```

```sh
yarn fantom packages/react-native/Libraries/Lists/__tests__/FlatList-itest.js packages/react-native/Libraries/Lists/__tests__/SectionList-itest.js --runInBand
```

```sh
yarn flow check
```

```sh
yarn fantom --benchmarks packages/react-native/Libraries/Lists/__tests__/VirtualizedList-stickyHeaders-benchmark-itest.js --runInBand
```

El PR cambió tres archivos:

- la implementación de `VirtualizedList`
- pruebas enfocadas de `VirtualizedList`
- un benchmark de Fantom para el camino de la máscara de render con sticky headers

Se importó mediante el proceso de Meta y se fusionó en `react/react-native`.

### Reflexiones finales

Lo que me gusta de esta contribución es que los desarrolladores de apps no tienen que hacer nada.

Ninguna prop nueva.

Ninguna migración.

Ningún parche.

Si una app usa una `FlatList` grande sin sticky headers, React Native ahora puede evitar un trabajo de búsqueda de sticky headers que para empezar era innecesario.

Ese es mi tipo favorito de mejora en un framework.

Poca superficie. Un benchmark claro. Ningún cambio de API.

Y un camino común se vuelve más barato para todos.

