Blog

Arrêtez d’utiliser React Native Async Storage

10 février 2023 6 min de lecture

Pourquoi abandonner React Native Async Storage, et ce que des alternatives modernes comme MMKV apportent en performance et en sécurité.

Arrêtez d’utiliser React Native Async Storage
React NativeAsync StorageAsyncStorageMMKVStockageSécuritéPerformance

Comparaison entre React Native MMKV et React Native Async Storage

Pendant longtemps, React Native Async Storage a été l’option par défaut pour stocker des données dans les applications React Native. Mais l’arrivée de React-Native MMKV offre aux développeurs un choix plus efficace et plus avancé.

MMKV a été conçu à l’origine comme un framework de stockage clé-valeur mobile, efficace, léger et simple à utiliser, pour l’application WeChat.

Il apporte à React Native ses bindings rapides et directs vers la bibliothèque native C++, via une API JavaScript simple. React-Native MMKV est aujourd’hui une option incontournable pour le stockage de données dans les applications React Native. L’un de ses principaux avantages est la performance. Comme tout est écrit en C++, il est environ 30 fois plus rapide qu’AsyncStorage. Il prend aussi en charge le chiffrement, ce qui en fait une solution de stockage sécurisée pour votre application. L’utilisation de JSI à la place de l’« ancien » Bridge améliore encore sa vitesse et son efficacité.

Benchmark

MMKV face aux autres bibliothèques de stockage : lecture d’une valeur dans le stockage 1000 fois. Mesuré en millisecondes sur un iPhone 11 Pro, plus c’est bas, mieux c’est.

https://github.com/mrousavy/react-native-mmkv#benchmarkhttps://github.com/mrousavy/react-native-mmkv#benchmark

Pas d’async/await

React-Native MMKV propose aussi des appels entièrement synchrones, ce qui le rend simple à utiliser, sans async/await ni Promises. C’est l’inverse d’AsyncStorage, qui impose un comportement asynchrone. Avec react-native-mmkv, on stocke et on récupère des données facilement avec de simples getters et setters. Voyons comment initialiser notre stockage avec react-native-mmkv :

import { MMKV } from "react-native-mmkv";

export const appStorage = new MMKV({
  id: "my-app-storage",
});

Récupérer des données depuis le stockage est tout aussi simple, comme le montre l’exemple ci-dessous :

// set a new key/value pair using react-native-mmkv
appStorage.set("username", "John");
const username = appStorage.getString("username");

// below is how you would do using react-native-async-storage
await AsyncStorage.setItem("username", "John");
const username = await AsyncStorage.getItem("username");

React-Native MMKV permet aussi de stocker des objets, ce qui facilite l’enregistrement de structures de données complexes. C’est ce que montre le code suivant :

// Objects

// using react-native-mmkv

const user = {
  username: "John",
  role: "Admin",
};

appStorage.set("user", JSON.stringify(user));

const jsonUser = appStorage.getString("user");
const userObject = JSON.parse(jsonUser);

// using react-native-async-storage

await AsyncStorage.setItem("user", JSON.stringify(user));
const jsonUser = await AsyncStorage.getItem("user");
const userObject = JSON.parse(jsonUser);

Supprimer des éléments du stockage est tout aussi facile, comme ci-dessous :

// to remove specific item from the storage in mmkv
appStorage.delete("username");

// below is how you would do using react-native-async-storage
await AsyncStorage.removeItem("username");

Exemple concret : le middleware persist de Zustand avec React Native MMKV

React-Native MMKV peut s’intégrer aux bibliothèques de state management populaires comme jotai, redux-persist, mobx-persist et zustand-persist-middleware. Les développeurs profitent ainsi du stockage efficace, rapide et simple de MMKV avec leurs solutions de state management existantes. Le résultat est une gestion du state fluide et simplifiée, qui permet de gérer et de persister plus facilement les données de l’application.

import { Appearance } from "react-native";
import { MMKV } from "react-native-mmkv";
import create from "zustand";
import { persist, StateStorage } from "zustand/middleware";

type AppPersistStore = {
  isDarkTheme: boolean;
  setIsDarkTheme: (preference: boolean) => void;
};

export const appPersistStorage = new MMKV({ id: "app-persist-storage" });

const zustandMMKVStorage: StateStorage = {
  setItem: (name, value) => {
    return appPersistStorage.set(name, value);
  },
  getItem: (name) => {
    const value = appPersistStorage.getString(name);
    return value ?? null;
  },
  removeItem: (name) => {
    return appPersistStorage.delete(name);
  },
};

export const useAppPersistStore = create<
  AppPersistStore,
  [["zustand/persist", AppPersistStore]]
>(
  persist(
    (set, get) => ({
      isDarkTheme: Appearance.getColorScheme() === "dark",
      setIsDarkTheme: (preference) => set({ isDarkTheme: preference }),
    }),
    {
      name: "app-persist-storage",
      getStorage: () => zustandMMKVStorage,
      serialize: (state) => JSON.stringify(state),
      deserialize: (state) => JSON.parse(state),
    }
  )
);

L’extrait de code ci-dessus montre comment utiliser zustand-persist-middleware avec react-native-mmkv pour gérer le thème clair/sombre de l’application. La combinaison de ces deux bibliothèques permet de persister le state de l’application, même après sa fermeture ou son redémarrage.

On déclare un type personnalisé, AppPersistStore, qui contient la préférence de thème de l’application et une méthode pour la modifier.

Ensuite, on crée une instance de MMKV, qui servira à persister le state de notre application. Cette instance est stockée dans une constante appelée appPersistStorage.

On crée ensuite un objet, zustandMMKVStorage, qui implémente l’interface StateStorage. Cet objet fournit un ensemble de méthodes qui nous permettent d’interagir avec l’instance appPersistStorage, par exemple pour définir et récupérer des valeurs.

Enfin, on utilise la fonction create de la bibliothèque zustand pour créer un hook appelé useAppPersistStore, qui renvoie la préférence de thème actuelle de l’application ainsi qu’une méthode pour la modifier. On utilise le middleware persist pour que le state de notre application soit automatiquement sauvegardé dans l’instance appPersistStorage à chaque changement.

Chaque fois qu’on appelle une action de ce store, elle est persistée : même si l’application est fermée ou redémarrée, son state reste identique à celui de la dernière utilisation. Cela offre une expérience cohérente à l’utilisateur, quel que soit le moment ou la manière dont il utilise l’application.

Voici comment on utiliserait ce hook au final :

import * as React from "react";
import { Button } from "react-native";
import { useAppPersistStore } from "./app-persist";

const Home: React.FC = () => {
  // here we have our mmkv and zustand persist-middleware hook that we have initialized previously
  const { isDarkTheme, setIsDarkTheme } = useAppPersistStore();

  return (
    <Button
      onPress={() => setIsDarkTheme(!isDarkTheme)}
      title={isDarkTheme ? "Dark Theme" : "Light theme"}
    />
  );
};

export default Home;

Les listeners avec react-native-mmkv

On peut utiliser la fonctionnalité de listener de React Native MMKV pour suivre les changements dans le stockage. C’est utile pour déclencher certaines actions chaque fois qu’une valeur précise change dans le stockage.

Voici un exemple d’utilisation du listener dans une application React Native :

import * as React from "react";
import { Button } from "react-native";
import { MMKV } from "react-native-mmkv";

const storage = new MMKV({ id: "theme-preference" });

const Home: React.FC = () => {
  const [isDarkTheme, setIsDarkTheme] = React.useState(false);

  React.useEffect(() => {
    const listener = storage.addOnValueChangedListener((changedKey) => {
      const newValue = storage.getString(changedKey);

      if (changedKey === "isDarkTheme") {
        // update the theme in the app based on the updated value in the storage
        console.log(`New theme preference: ${newValue}`);
      }
    });

    return () => {
      listener.remove();
    };
  }, []);

  const toggleTheme = () => {
    const newPreference = !isDarkTheme;
    setIsDarkTheme(newPreference);
    storage.set("isDarkTheme", JSON.stringify(newPreference));
  };

  return (
    <Button
      onPress={toggleTheme}
      title={isDarkTheme ? "Dark Theme" : "Light Theme"}
    />
  );
};

Dans cet exemple, on crée un stockage MMKV avec l’ID theme-preference et on lui ajoute un listener grâce à la méthode addOnValueChangedListener. Le listener écoute les changements dans le stockage et met à jour le thème de l’application en conséquence.

L’exemple ci-dessus sert à illustrer l’utilisation du listener de React Native MMKV avec un minimum de code, plutôt qu’à être un exemple réellement utile. Dans cet extrait, le listener écoute les changements dans le stockage et affiche les nouvelles valeurs de la clé modifiée.

Utilisation avec Expo

React native mmkv est bien compatible avec expo, mais comme il repose sur des modules natifs, il ne fonctionnera pas tel quel dans une application expo classique (sans code natif généré). Il faut générer le code natif, autrement dit utiliser la fonctionnalité prebuild d’expo.


Conclusion

En tant que développeur react native, je recommande vivement React Native MMKV comme solution de stockage pour les applications React Native. La bibliothèque documente son intégration avec d’autres bibliothèques de state management populaires comme jotai, redux-persist, mobx-persist et zustand-persist-middleware, ce qui la rend facile à intégrer dans n’importe quel projet.

Par rapport à React Native Async Storage, React Native MMKV offre plusieurs avantages décisifs : de hautes performances, la prise en charge du chiffrement et une API simple à utiliser. Ses appels entièrement synchrones, sans async/await ni Promises, en font un choix plus rapide et plus efficace.

Donc, si vous cherchez une solution de stockage fiable et sécurisée pour votre application React Native, je vous encourage à envisager React Native MMKV.

Ressources

Publié sur

Cet article est également publié sur :