Aller au contenu
Télécharger le CV

Écrits

Comment rendre le stockage local rapide en React Native avec MMKV

Accélérer le stockage local en React Native : pourquoi AsyncStorage est lent, le gain de MMKV, migration, Zustand, TanStack Query et astuces SQLite.

Publié le Mis à jour le 9 min de lecture

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

Réponse courte : le stockage local le plus rapide pour React Native est MMKV. Il lit environ 20 fois plus vite qu’AsyncStorage dans le benchmark publié, parce que c’est du C++ synchrone, sans aller-retour par une Promise. Pour rendre votre application rapide, déplacez les petites données utilisées souvent vers MMKV, lisez-les de façon synchrone au démarrage, gardez des valeurs petites, écrivez moins souvent, et utilisez SQLite avec des index et des transactions pour tout ce qui ressemble à une table.

Sur une application sociale React Native avec des fils, des profils et des messages, les données locales passent par MMKV, et c’est en grande partie pour ça que les écrans s’ouvrent avec leur contenu déjà affiché sur des téléphones Android de milieu de gamme. Si vous hésitez encore sur le stockage à utiliser, commencez par mon comparatif MMKV, AsyncStorage, SQLite et SecureStore. Cet article parle de vitesse.

Pourquoi le stockage local ralentit une application

Le stockage apparaît rarement comme un seul gros appel lent. Il apparaît sous forme de nombreux petits retards :

  • Des lectures asynchrones au démarrage. Chaque await AsyncStorage.getItem() avant le premier écran représente au moins une frame pendant laquelle l’utilisateur voit un spinner ou un flash du thème par défaut.
  • Une seule valeur JSON géante. Sauvegarder tout l’état de l’application sous une seule clé signifie que chaque petite modification réécrit et reparse tout le bloc.
  • Une écriture à chaque frappe. Un brouillon sauvegardé à chaque caractère transforme la saisie en une suite d’écritures disque.
  • Le filtrage en JavaScript. Charger 5000 enregistrements depuis un stockage clé-valeur pour en afficher 20 gaspille de la mémoire et du temps qu’une requête de base de données vous éviterait.

Pour les trois premiers, la solution est un stockage clé-valeur plus rapide, utilisé avec soin. Pour le dernier, c’est une vraie base de données.

Quel stockage local est le plus rapide ?

L’application StorageBenchmark lit une même valeur 1000 fois avec chaque bibliothèque. AsyncStorage a eu besoin de 242 ms pour ça. Voici combien de lectures chacune des autres bibliothèques termine dans ces mêmes 242 ms :

Lectures terminées en 242 ms, le temps qu'il faut à AsyncStorage pour en faire 1000 (plus c'est long, plus c'est rapide)
MMKV20 167
WatermelonDB4 566
Realm2 988
SQLite (quick-sqlite)2 951
AsyncStorage1 000

Calculé à partir des résultats publiés de mrousavy/StorageBenchmark (MMKV 12 ms, WatermelonDB 53 ms, Realm 81 ms, quick-sqlite 82 ms, AsyncStorage 242 ms pour 1000 lectures sur un iPhone 11 Pro, Hermes, build de debug).

Les mêmes chiffres sous forme de tableau :

Bibliothèque 1000 lectures Par lecture Comparé à MMKV
MMKV 12 ms 0,012 ms le plus rapide
WatermelonDB 53 ms 0,053 ms 4,4x plus lent
Realm 81 ms 0,081 ms 6,8x plus lent
SQLite (react-native-quick-sqlite) 82 ms 0,082 ms 6,8x plus lent
AsyncStorage 242 ms 0,242 ms 20x plus lent

Une lecture isolée est rapide avec n’importe laquelle. La différence compte parce que les applications font des centaines de lectures : chaque store persisté, chaque requête en cache, chaque hook qui vérifie un réglage. Deux précisions pour rester honnête : le benchmark a tourné dans un build de debug sous React Native 0.68, et AsyncStorage est depuis passé à un nouveau backend SQLite avec la version 3. J’explique plus bas comment lancer le même test sur votre propre appareil.

Pourquoi MMKV est tellement plus rapide

Trois choses s’additionnent :

  1. Pas de Promise et pas de bridge. react-native-mmkv appelle directement le C++ via JSI. Une lecture renvoie la valeur sur la même ligne : pas d’await, pas de file d’attente et pas de rendu supplémentaire pendant l’attente.
  2. Un fichier projeté en mémoire. MMKV projette son fichier en mémoire avec mmap. Lire une clé revient à une recherche en mémoire, et les écritures vont d’abord en mémoire pendant que le système d’exploitation les enregistre sur le disque.
  3. Un encodage compact. Les valeurs sont stockées avec protobuf, qui est compact et rapide à encoder et décoder.

Étape 1 : déplacer les données chaudes vers MMKV

Installez-le (versions sur npm au moment où j’écris : react-native-mmkv 4.3.2 avec react-native-nitro-modules 0.37.1) :

# Expo (nécessite un development build, pas Expo Go)
npx expo install react-native-mmkv react-native-nitro-modules
npx expo prebuild

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

MMKV 4 demande React Native 0.76 ou plus récent. Si vous êtes encore sur Expo Go, lisez d’abord Expo Go vs development builds ; le passage prend une dizaine de minutes.

Créez vos instances une seule fois, dans un seul fichier, et importez-les partout :

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

// Valeurs globales de l'app : thème, langue, onboarding, feature flags
export const appStorage = createMMKV({ id: 'app' });

// Données serveur en cache, qu'on peut effacer à tout moment
export const cacheStorage = createMMKV({ id: 'cache' });

// Valeurs propres à chaque utilisateur, effacées à la déconnexion
export const userStorage = (userId: string) => createMMKV({ id: `user-${userId}` });

Des instances séparées gardent des fichiers petits et simplifient la déconnexion : vous videz l’instance de l’utilisateur et le cache, et vous gardez les réglages de l’application.

Étape 2 : migrer depuis AsyncStorage sans perdre de données

Si votre application est déjà en ligne, vos utilisateurs ont des données dans AsyncStorage. Copiez-les une fois, puis supprimez-les. Ce code est adapté du guide de migration officiel :

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);
}

J’importe volontairement l’AsyncStorage par défaut ici : en version 3, il pointe toujours vers les anciennes données v2, et c’est exactement là que vos utilisateurs existants ont leurs valeurs. Lancez la migration avant que l’application ne lise l’une de ces clés, et affichez le splash screen jusqu’à ce qu’elle se termine. Elle ne s’exécute qu’une fois par installation.

Étape 3 : lire l’état de façon synchrone au démarrage

C’est là que les utilisateurs sentent vraiment la différence. Avec AsyncStorage, un store persisté se charge après le premier rendu, donc l’application affiche brièvement les valeurs par défaut puis saute. Avec MMKV, le store est prêt avant le premier rendu.

Avec le middleware persist de Zustand, fournissez-lui un stockage basé sur MMKV (Zustand 5.0.16 au moment où j’écris) :

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) }
  )
);

Comme le stockage est synchrone, le store s’hydrate dès sa création, donc la première frame affiche déjà le thème de l’utilisateur. Le même principe fonctionne avec Redux Persist et Jotai ; le dépôt MMKV propose des adaptateurs prêts à l’emploi.

Pour les données serveur, persistez le cache de TanStack Query dans MMKV pour que les listes s’affichent instantanément au lancement suivant, pendant que les données fraîches se chargent en arrière-plan :

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),
  },
});

Enveloppez ensuite votre application dans PersistQueryClientProvider avec persistOptions={{ persister: queryPersister }}. C’est la combinaison sur laquelle je m’appuie pour les écrans de type fil : des données en cache à l’écran dès le lancement, des données fraîches un instant plus tard.

Étape 4 : garder des valeurs petites et découper par clé

MMKV garde tout le fichier en mémoire, et chaque écriture enregistre à nouveau la valeur complète de la clé, même si un seul champ a changé à l’intérieur. Donc :

  • Découpez les gros objets. Stockez settings.theme et settings.language sous des clés séparées plutôt qu’un seul objet settings, quand ils changent indépendamment.
  • Ne stockez pas de listes d’enregistrements. Une liste de 3000 commandes dans une seule chaîne JSON est lente à parser et gaspille de la mémoire. C’est le travail de SQLite.
  • Stockez les fichiers comme des fichiers. Images, PDF et audio vont dans le système de fichiers. Ne gardez que le chemin dans MMKV.
  • Faites le ménage dans les caches. cacheStorage.byteSize vous donne la taille d’une instance. Appelez cacheStorage.trim() après avoir supprimé beaucoup de clés pour libérer de la mémoire.

Étape 5 : écrire moins souvent

Des écritures rapides restent des écritures. Deux habitudes aident :

Appliquez un debounce aux brouillons et à la saisie. Sauvegardez quand l’utilisateur arrête de taper, pas à chaque caractère :

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]);
}

Évitez les écritures qui ne changent rien. Si une partie du code réécrit sans cesse la même valeur, créez l’instance avec compareBeforeSet: true. MMKV compare alors la nouvelle valeur avec celle déjà stockée et saute l’écriture disque si elles sont identiques.

Étape 6 : rendre SQLite rapide quand il vous faut une base de données

Quand les données ont vraiment leur place dans des tables, MMKV est le mauvais outil et SQLite est le bon, à condition de bien l’utiliser. Voici les réglages et habitudes qui font la plus grosse différence, illustrés avec expo-sqlite :

import * as SQLite from 'expo-sqlite';

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

// WAL permet aux lectures et aux écritures de se faire en même temps
await db.execAsync('PRAGMA journal_mode = WAL;');

// Indexez les colonnes sur lesquelles vous filtrez et triez
await db.execAsync('CREATE INDEX IF NOT EXISTS idx_orders_created ON orders (created_at);');

// Insérez beaucoup de lignes dans une seule transaction, pas une transaction par ligne
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);
  }
});

// Ne demandez que les colonnes et les lignes affichées à l'écran
const page = await db.getAllAsync('SELECT id, total FROM orders ORDER BY created_at DESC LIMIT 20 OFFSET ?', offset);

Une transaction autour d’une insertion groupée est souvent le plus gros gain à elle seule : sans elle, SQLite valide et synchronise sur le disque après chaque ligne. Si vous avez besoin de vitesse brute au-delà, op-sqlite est un binding JSI pensé pour la performance.

Si vous devez rester sur AsyncStorage

Parfois, vous ne pouvez pas encore ajouter de code natif, par exemple dans un prototype Expo Go. Vous pouvez quand même rendre AsyncStorage plus réactif :

  • Groupez les appels. Utilisez getMany et setMany (v3) ou multiGet et multiSet (v2) au lieu de boucles d’appels unitaires.
  • Lisez une fois, gardez en mémoire. Chargez les réglages au démarrage dans un store, puis lisez depuis le store.
  • Ne bloquez pas le premier écran. Affichez l’interface avec des valeurs par défaut raisonnables et appliquez les valeurs stockées quand elles arrivent, ou gardez le splash screen jusqu’à ce que les quelques valeurs vraiment nécessaires soient chargées.

Mesurez sur votre propre appareil

Les benchmarks faits sur le téléphone de quelqu’un d’autre sont un point de départ. Ce snippet compare 1000 lectures sur votre appareil :

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`);
}

Lancez-le dans un build de release sur le téléphone Android le moins cher que vous trouverez. Les builds de debug et les simulateurs donnent des chiffres très différents, et c’est sur un téléphone lent que vos utilisateurs remarquent le stockage en premier.

Questions fréquentes

Quel est le stockage local le plus rapide pour React Native ?

MMKV, via la bibliothèque react-native-mmkv. Il est synchrone, écrit en C++, et lit environ 20 fois plus vite qu’AsyncStorage et 4 fois plus vite que l’option suivante dans les résultats publiés de StorageBenchmark. Pour des données relationnelles, un binding SQLite en JSI comme op-sqlite est l’option de base de données la plus rapide.

Pourquoi AsyncStorage est-il lent ?

Chaque appel renvoie une Promise et passe par un module natif, donc chaque lecture attend le tour suivant de l’event loop JavaScript. Avec beaucoup de petites lectures, surtout au démarrage, ces attentes s’accumulent. Il ne stocke en plus que des chaînes, donc les objets sont reparsés depuis le JSON à chaque lecture.

MMKV est-il 30 fois plus rapide qu’AsyncStorage ?

Le README de MMKV annonce « ~30x ». Les chiffres publiés de StorageBenchmark (12 ms contre 242 ms pour 1000 lectures) donnent environ 20 fois. L’écart réel dans votre application dépend de l’appareil, du type de build et de la version d’AsyncStorage, alors mesurez-le avec le snippet ci-dessus.

MMKV rend-il toute l’application plus rapide ?

Il accélère les lectures et écritures du stockage et supprime les flashs de chargement au démarrage. Il ne corrigera pas des listes lentes, des rendus lourds ou de grosses images. Si votre application ne passe pas son temps dans le stockage, le changement apporte un gain plus modeste, donc profilez d’abord.

MMKV peut-il remplacer SQLite ?

Seulement pour des données clé-valeur. Si vous avez besoin de requêtes, de tri, de relations ou de milliers d’enregistrements, gardez SQLite et utilisez MMKV à côté pour les réglages et les petites valeurs en cache.

MMKV est-il sûr pour les tokens ?

MMKV sans chiffrement stocke les données en clair dans le sandbox de l’application, donc ce n’est pas le bon endroit pour des tokens. Vous pouvez activer le chiffrement AES, mais gardez la clé de chiffrement elle-même dans SecureStore ou Keychain. J’explique toute la mise en place dans comment stocker des tokens d’authentification de façon sécurisée en React Native.


Vous ne savez pas encore quel stockage il faut à votre application ? Lisez MMKV vs AsyncStorage vs SQLite vs SecureStore. Si votre application React Native vous paraît lente et que vous voulez quelqu’un pour trouver pourquoi, contactez-moi.

Autres articles

Vous avez une app en tête ?

Parlez-moi de votre projet. Je réponds à chaque demande sérieuse sous deux jours ouvrés.