Saltar al contenido
Descargar CV

Escritos

Cómo hacer rápido el almacenamiento local en React Native con MMKV

Acelera el almacenamiento local en React Native: por qué AsyncStorage es lento, cuánto gana MMKV, migración, Zustand, TanStack Query y trucos de SQLite.

Publicado el Actualizado el 9 min de lectura

  • React Native
  • MMKV
  • Performance
  • Expo
  • TypeScript
  • SQLite

Respuesta corta: el almacenamiento local más rápido para React Native es MMKV. En el benchmark publicado lee unas 20 veces más rápido que AsyncStorage porque es C++ síncrono, sin el viaje de ida y vuelta de una Promise. Para que tu app vaya rápida, mueve a MMKV los datos pequeños y de uso frecuente, léelos de forma síncrona al arrancar, mantén los valores pequeños, escribe con menos frecuencia y usa SQLite con índices y transacciones para todo lo que parezca una tabla.

En una app social de React Native con feeds, perfiles y mensajes, los datos locales pasan por MMKV, y eso explica en buena parte por qué las pantallas se abren con el contenido ya cargado en móviles Android de gama media. Si todavía estás eligiendo qué almacenamiento usar, empieza por mi comparativa de MMKV, AsyncStorage, SQLite y SecureStore. Este artículo trata de la velocidad.

Por qué el almacenamiento local hace que una app parezca lenta

El almacenamiento rara vez aparece como una gran llamada lenta. Aparece como muchos retrasos pequeños:

  • Lecturas asíncronas al arrancar. Cada await AsyncStorage.getItem() antes de la primera pantalla es al menos un frame en el que el usuario ve un spinner o un destello del tema por defecto.
  • Un único JSON gigante. Guardar todo el estado de la app bajo una sola clave significa que cada cambio pequeño reescribe y vuelve a parsear el bloque entero.
  • Escribir en cada pulsación. Un borrador guardado con cada carácter convierte la escritura en un chorro de escrituras en disco.
  • Filtrar en JavaScript. Cargar 5000 registros de un almacenamiento clave valor para mostrar 20 desperdicia memoria y tiempo que una consulta a una base de datos no gastaría.

La solución para los tres primeros es un almacenamiento clave valor más rápido, usado con cuidado. La solución para el último es una base de datos de verdad.

¿Cuál es el almacenamiento local más rápido?

La app StorageBenchmark lee un valor 1000 veces con cada librería. AsyncStorage necesitó 242 ms para eso. Esta es la cantidad de lecturas que completa cada una de las demás librerías en esos mismos 242 ms:

Lecturas completadas en 242 ms, el tiempo que AsyncStorage necesita para 1000 (barra más larga, más rápido)
MMKV20.167
WatermelonDB4.566
Realm2.988
SQLite (quick-sqlite)2.951
AsyncStorage1.000

Calculado a partir de los resultados publicados de mrousavy/StorageBenchmark (MMKV 12 ms, WatermelonDB 53 ms, Realm 81 ms, quick-sqlite 82 ms, AsyncStorage 242 ms para 1000 lecturas en un iPhone 11 Pro, Hermes, build de depuración).

Los mismos números en una tabla:

Librería 1000 lecturas Por lectura Comparado con MMKV
MMKV 12 ms 0,012 ms la más rápida
WatermelonDB 53 ms 0,053 ms 4,4 veces más lenta
Realm 81 ms 0,081 ms 6,8 veces más lenta
SQLite (react-native-quick-sqlite) 82 ms 0,082 ms 6,8 veces más lenta
AsyncStorage 242 ms 0,242 ms 20 veces más lenta

Una sola lectura es rápida con cualquiera de ellas. La diferencia importa porque las apps hacen cientos de lecturas: cada store persistido, cada consulta en caché, cada hook que comprueba un ajuste. Dos matices para ser honesto: el benchmark se ejecutó en una build de depuración con React Native 0.68, y desde entonces AsyncStorage ha pasado a un nuevo backend en SQLite en la versión 3. Más abajo explico cómo hacer la misma prueba en tu propio dispositivo.

Por qué MMKV es tanto más rápido

Se suman tres cosas:

  1. Sin Promise y sin bridge. react-native-mmkv llama directamente a C++ a través de JSI. Una lectura devuelve el valor en la misma línea, así que no hay await, ni cola, ni un render extra mientras esperas.
  2. Archivo proyectado en memoria. MMKV proyecta su archivo en memoria con mmap. Leer una clave es una consulta en memoria, y las escrituras van primero a la memoria mientras el sistema operativo las guarda en disco.
  3. Codificación compacta. Los valores se guardan con protobuf, que ocupa poco y se codifica y decodifica rápido.

Paso 1: mueve los datos más usados a MMKV

Instálalo (versiones en npm cuando escribí esto: react-native-mmkv 4.3.2 con react-native-nitro-modules 0.37.1):

# Expo (necesita un development build, no Expo Go)
npx expo install react-native-mmkv react-native-nitro-modules
npx expo prebuild

# React Native sin Expo
npm install react-native-mmkv react-native-nitro-modules
cd ios && pod install

MMKV 4 necesita React Native 0.76 o superior. Si hoy estás en Expo Go, lee primero Expo Go vs development builds; el cambio lleva unos diez minutos.

Crea tus instancias una sola vez, en un archivo, e impórtalas en todas partes:

// storage.ts
import { createMMKV } from 'react-native-mmkv';

// Valores de toda la app: tema, idioma, onboarding, feature flags
export const appStorage = createMMKV({ id: 'app' });

// Datos del servidor en caché, se pueden borrar en cualquier momento
export const cacheStorage = createMMKV({ id: 'cache' });

// Valores por usuario, se borran al cerrar sesión
export const userStorage = (userId: string) => createMMKV({ id: `user-${userId}` });

Tener instancias separadas mantiene los archivos pequeños y simplifica el cierre de sesión: borras la instancia del usuario y la caché, y conservas los ajustes de la app.

Paso 2: migra desde AsyncStorage sin perder datos

Si tu app ya está publicada, los usuarios tienen datos en AsyncStorage. Cópialos una vez y después bórralos. Esto está adaptado de la guía oficial de migración:

import AsyncStorage from '@react-native-async-storage/async-storage';
import { appStorage } from './storage';

export async function migrateFromAsyncStorage() {
  if (appStorage.getBoolean('migratedFromAsyncStorage')) return;

  const keys = await AsyncStorage.getAllKeys();
  for (const key of keys) {
    const value = await AsyncStorage.getItem(key);
    if (value == null) continue;
    if (value === 'true' || value === 'false') {
      appStorage.set(key, value === 'true');
    } else {
      appStorage.set(key, value);
    }
  }

  await AsyncStorage.multiRemove(keys);
  appStorage.set('migratedFromAsyncStorage', true);
}

Aquí importo a propósito el AsyncStorage por defecto: en la versión 3 sigue apuntando a los datos antiguos de la v2, que es justo donde los usuarios existentes tienen sus valores. Ejecuta la migración antes de que tu app lea cualquiera de esas claves y muestra la splash screen hasta que termine. Solo se ejecuta una vez por instalación.

Paso 3: lee el estado de forma síncrona al arrancar

Aquí es donde los usuarios notan de verdad el cambio. Con AsyncStorage, un store persistido se carga después del primer render, así que la app muestra un instante los valores por defecto y luego salta. Con MMKV, el store está listo antes del primer render.

Con el middleware persist de Zustand, pásale un almacenamiento respaldado por MMKV (Zustand 5.0.16 en el momento de escribir esto):

import { create } from 'zustand';
import { persist, createJSONStorage, type StateStorage } from 'zustand/middleware';
import { appStorage } from './storage';

const mmkvStorage: StateStorage = {
  getItem: (name) => appStorage.getString(name) ?? null,
  setItem: (name, value) => appStorage.set(name, value),
  removeItem: (name) => appStorage.remove(name),
};

type Settings = { theme: 'light' | 'dark'; autoplay: boolean; setTheme: (t: 'light' | 'dark') => void };

export const useSettings = create<Settings>()(
  persist(
    (set) => ({
      theme: 'dark',
      autoplay: true,
      setTheme: (theme) => set({ theme }),
    }),
    { name: 'settings', storage: createJSONStorage(() => mmkvStorage) }
  )
);

Como el almacenamiento es síncrono, el store se hidrata al crearse, así que el primer frame ya tiene el tema del usuario. El mismo patrón funciona con Redux Persist y Jotai; el repositorio de MMKV tiene wrappers listos para usar.

Para los datos del servidor, persiste la caché de TanStack Query en MMKV para que las listas aparezcan al instante en el siguiente arranque mientras los datos nuevos se cargan en segundo plano:

import { createAsyncStoragePersister } from '@tanstack/query-async-storage-persister';
import { cacheStorage } from './storage';

export const queryPersister = createAsyncStoragePersister({
  storage: {
    getItem: (key) => cacheStorage.getString(key) ?? null,
    setItem: (key, value) => cacheStorage.set(key, value),
    removeItem: (key) => cacheStorage.remove(key),
  },
});

Después envuelve tu app en PersistQueryClientProvider con persistOptions={{ persister: queryPersister }}. Es la combinación en la que confío para pantallas tipo feed: datos en caché en pantalla al arrancar y datos frescos un momento después.

Paso 4: mantén los valores pequeños y repártelos en claves

MMKV mantiene todo el archivo en memoria, y cada escritura vuelve a guardar el valor completo de esa clave, aunque solo haya cambiado un campo dentro. Así que:

  • Divide los objetos grandes. Guarda settings.theme y settings.language como claves separadas en lugar de un único objeto settings, cuando cambian de forma independiente.
  • No guardes listas de registros. Una lista de 3000 pedidos como un único string JSON es lenta de parsear y desperdicia memoria. Ese es el trabajo de SQLite.
  • Guarda los archivos como archivos. Las imágenes, los PDF y el audio van al sistema de archivos. En MMKV guarda solo la ruta.
  • Recorta las cachés. cacheStorage.byteSize te dice cuánto ocupa una instancia. Llama a cacheStorage.trim() después de borrar muchas claves para liberar memoria.

Paso 5: escribe con menos frecuencia

Las escrituras rápidas siguen siendo escrituras. Dos hábitos ayudan:

Aplica debounce a los borradores y al texto. Guarda cuando el usuario deja de escribir en lugar de con cada carácter:

import { useEffect } from 'react';
import { appStorage } from './storage';

export function usePersistDraft(key: string, text: string) {
  useEffect(() => {
    const timer = setTimeout(() => appStorage.set(key, text), 400);
    return () => clearTimeout(timer);
  }, [key, text]);
}

Sáltate las escrituras que no cambian nada. Si alguna parte del código guarda el mismo valor una y otra vez, crea la instancia con compareBeforeSet: true. MMKV compara entonces el valor nuevo con el guardado y se salta la escritura en disco cuando coinciden.

Paso 6: haz rápido SQLite cuando necesites una base de datos

Cuando los datos de verdad pertenecen a tablas, MMKV es la herramienta equivocada y SQLite es la rápida, siempre que la uses bien. Estos son los ajustes y hábitos que más se notan, mostrados con expo-sqlite:

import * as SQLite from 'expo-sqlite';

const db = await SQLite.openDatabaseAsync('app.db');

// WAL permite lecturas y escrituras al mismo tiempo
await db.execAsync('PRAGMA journal_mode = WAL;');

// Indexa las columnas por las que filtras y ordenas
await db.execAsync('CREATE INDEX IF NOT EXISTS idx_orders_created ON orders (created_at);');

// Inserta muchas filas en una sola transacción, no una transacción por fila
await db.withTransactionAsync(async () => {
  for (const order of orders) {
    await db.runAsync('INSERT INTO orders (id, total, created_at) VALUES (?, ?, ?)', order.id, order.total, order.createdAt);
  }
});

// Pide solo las columnas y filas que muestra la pantalla
const page = await db.getAllAsync('SELECT id, total FROM orders ORDER BY created_at DESC LIMIT 20 OFFSET ?', offset);

Una transacción alrededor de una inserción por lotes suele ser la mayor mejora de todas: sin ella, SQLite hace commit y sincroniza con el disco después de cada fila. Si necesitas todavía más velocidad, op-sqlite es un binding JSI pensado para el rendimiento.

Si tienes que quedarte con AsyncStorage

A veces todavía no puedes añadir código nativo, por ejemplo en un prototipo con Expo Go. Aun así puedes hacer que AsyncStorage parezca más rápido:

  • Agrupa las llamadas. Usa getMany y setMany (v3) o multiGet y multiSet (v2) en lugar de bucles de llamadas sueltas.
  • Lee una vez y guárdalo en memoria. Carga los ajustes al arrancar en un store y después lee desde el store.
  • No bloquees la primera pantalla. Muestra la interfaz con valores por defecto razonables y aplica los valores guardados cuando lleguen, o mantén la splash screen hasta que se carguen los pocos valores que de verdad necesitas.

Mídelo en tu propio dispositivo

Los benchmarks hechos en el móvil de otra persona son un punto de partida. Este fragmento compara 1000 lecturas en tu dispositivo:

import { createAsyncStorage } from '@react-native-async-storage/async-storage';
import { createMMKV } from 'react-native-mmkv';

export async function storageBenchmark() {
  const mmkv = createMMKV({ id: 'bench' });
  const asyncStorage = createAsyncStorage('bench');
  mmkv.set('key', 'hello');
  await asyncStorage.setItem('key', 'hello');

  let start = performance.now();
  for (let i = 0; i < 1000; i++) mmkv.getString('key');
  const mmkvMs = performance.now() - start;

  start = performance.now();
  for (let i = 0; i < 1000; i++) await asyncStorage.getItem('key');
  const asyncMs = performance.now() - start;

  console.log(`MMKV: ${mmkvMs.toFixed(1)} ms, AsyncStorage: ${asyncMs.toFixed(1)} ms, ${(asyncMs / mmkvMs).toFixed(1)}x`);
}

Ejecútalo en una build de release en el móvil Android más barato que encuentres. Las builds de depuración y los simuladores dan números muy distintos, y un móvil lento es donde tus usuarios notan primero el almacenamiento.

Preguntas frecuentes

¿Cuál es el almacenamiento local más rápido para React Native?

MMKV, a través de la librería react-native-mmkv. Es síncrono, está escrito en C++ y en el StorageBenchmark publicado lee unas 20 veces más rápido que AsyncStorage y 4 veces más rápido que la siguiente opción. Para datos relacionales, un binding JSI de SQLite como op-sqlite es la base de datos más rápida.

¿Por qué AsyncStorage es lento?

Cada llamada devuelve una Promise y pasa por un módulo nativo, así que cada lectura espera al siguiente turno del event loop de JavaScript. Con muchas lecturas pequeñas, sobre todo al arrancar, esas esperas se acumulan. Además solo guarda strings, así que los objetos se parsean desde JSON en cada lectura.

¿MMKV es 30 veces más rápido que AsyncStorage?

El README de MMKV dice “~30x”. Los números publicados del StorageBenchmark (12 ms frente a 242 ms para 1000 lecturas) salen a unas 20 veces. La diferencia real en tu app depende del dispositivo, del tipo de build y de la versión de AsyncStorage, así que mídela con el fragmento de arriba.

¿MMKV hace más rápida toda la app?

Hace más rápidas las lecturas y escrituras del almacenamiento y elimina los parpadeos de carga al arrancar. No arreglará listas lentas, renders pesados ni imágenes grandes. Si tu app no pierde el tiempo en el almacenamiento, el cambio aporta menos, así que primero haz un perfil.

¿Puede MMKV sustituir a SQLite?

Solo para datos clave valor. Si necesitas consultas, ordenación, relaciones o miles de registros, quédate con SQLite y usa MMKV a su lado para los ajustes y los valores pequeños en caché.

¿Es MMKV seguro para guardar tokens?

MMKV sin cifrado guarda los datos sin cifrar dentro del sandbox de la app, así que no es el sitio adecuado para tokens. Puedes activar el cifrado AES, pero guarda la propia clave de cifrado en SecureStore o Keychain. Explico la configuración completa en cómo guardar tokens de autenticación de forma segura en React Native.


¿No tienes claro qué almacenamiento necesita tu app? Lee MMKV vs AsyncStorage vs SQLite vs SecureStore. Si tu app de React Native va lenta y quieres que alguien descubra por qué, escríbeme.

Más artículos

¿Tienes una app en mente?

Cuéntame qué estás construyendo. Respondo a cada consulta seria en un plazo de dos días laborables.