Blog

Stop met React Native Async Storage

10 februari 2023 6 min leestijd

Waarom je beter kunt overstappen van React Native Async Storage en wat moderne alternatieven zoals MMKV bieden op het gebied van prestaties en beveiliging.

Stop met React Native Async Storage
React NativeAsync StorageAsyncStorageMMKVOpslagBeveiligingPrestaties

Een vergelijking tussen React Native MMKV en React Native Async Storage

Al een flinke tijd is React Native Async Storage de standaardkeuze om data op te slaan in React Native-applicaties. Met de komst van React-Native MMKV hebben developers echter een efficiëntere en geavanceerdere optie.

MMKV is oorspronkelijk ontworpen als een efficiënt, klein en gebruiksvriendelijk framework voor key-value-opslag op mobiel, voor de app WeChat.

Het brengt zijn snelle, directe bindings met de native C++-library naar het React Native-platform via een eenvoudige JavaScript-API. React-Native MMKV is inmiddels een belangrijke optie voor dataopslag in React Native-applicaties. Een van de grote voordelen van React-Native MMKV is de performance. Omdat alles in C++ is geschreven, is het ~30x sneller dan AsyncStorage. Daarnaast ondersteunt het encryptie, waardoor het een veilige opslagoplossing voor je app is. Het gebruik van JSI in plaats van de "oude" Bridge maakt het nog sneller en efficiënter.

Benchmark

MMKV tegenover andere opslaglibraries: een waarde 1000 keer uit de opslag lezen. Gemeten in milliseconden op een iPhone 11 Pro, lager is beter.

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

Geen async/await

React-Native MMKV biedt ook volledig synchrone calls, zodat je het makkelijk kunt gebruiken zonder async/await of Promises. Dat is anders dan bij AsyncStorage, dat asynchroon werkt. Met react-native-mmkv sla je data eenvoudig op en haal je ze weer op met simpele getters en setters. Laten we kijken hoe we onze opslag initialiseren met react-native-mmkv:

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

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

Data uit de opslag ophalen is net zo eenvoudig, zoals je hieronder ziet:

// 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 ondersteunt ook het opslaan van objecten, waardoor je makkelijk complexe datastructuren kunt opslaan. Dat zie je in de volgende code:

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

Items uit de opslag verwijderen is net zo makkelijk, zoals hieronder te zien is:

// 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");

Voorbeeld uit de praktijk: Zustand middleware-persist en React Native MMKV

React-Native MMKV kan samenwerken met populaire libraries voor state management, zoals jotai, redux-persist, mobx-persist en zustand-persist-middleware. Zo kunnen developers de efficiënte, snelle en gebruiksvriendelijke opslag van MMKV combineren met hun bestaande oplossingen voor state management. Die integratie zorgt voor een soepele en gestroomlijnde ervaring met state management, waardoor het voor developers makkelijker wordt om de data van hun applicatie te beheren en te bewaren.

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

Het codefragment hierboven laat zien hoe je zustand-persist-middleware samen met react-native-mmkv gebruikt om het lichte of donkere thema van de app te beheren. Door deze twee libraries te combineren, kun je de state van de app bewaren, ook nadat de app is gesloten of opnieuw is gestart.

We declareren een eigen type, AppPersistStore, met informatie over de themavoorkeur van de app en een methode om die voorkeur te wijzigen.

Daarna maken we een MMKV-instantie aan, die we gebruiken om de state van onze app te bewaren. De instantie wordt opgeslagen in een constante met de naam appPersistStorage.

Vervolgens maken we een object, zustandMMKVStorage, dat de interface StateStorage implementeert. Dit object levert een set methodes waarmee we met de instantie appPersistStorage kunnen werken, zoals waarden instellen en ophalen.

Tot slot gebruiken we de functie create uit de library zustand om een hook met de naam useAppPersistStore te maken. Die geeft de huidige state van de themavoorkeur van de app terug, plus een methode om die voorkeur te wijzigen. We gebruiken de middleware persist om ervoor te zorgen dat de state van onze app automatisch in de instantie appPersistStorage wordt opgeslagen zodra de state verandert.

Elke keer dat we een action uit deze store aanroepen, wordt die bewaard. Dat betekent dat de state van de app hetzelfde blijft als bij het laatste gebruik, ook als de app wordt gesloten of opnieuw gestart. Zo krijgt de gebruiker een consistente ervaring, ongeacht wanneer of hoe de app wordt gebruikt.

Zo zouden we deze hook uiteindelijk gebruiken:

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;

Listeners met react-native-mmkv

Met de listener-functie van React Native MMKV kunnen we wijzigingen in de opslag volgen. Dat is handig om bepaalde acties uit te voeren zodra een specifieke waarde in de opslag verandert.

Hier is een voorbeeld van hoe we de listener in een React Native-applicatie kunnen gebruiken:

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

In dit voorbeeld hebben we een MMKV-opslag gemaakt met de ID theme-preference en er een listener aan toegevoegd met de methode addOnValueChangedListener. De listener luistert naar wijzigingen in de opslag en past het thema in de app daarop aan.

Het voorbeeld hierboven was bedoeld om met zo weinig mogelijk code te laten zien hoe de listener-functie in React Native MMKV werkt, niet als een zinvol voorbeeld. In het codefragment wordt de listener gebruikt om naar wijzigingen in de opslag te luisteren en de nieuwe waarden van de gewijzigde key te loggen.

Gebruik met Expo

React native mmkv is inderdaad compatibel met expo, maar omdat het bovenop native modules is gebouwd, werkt het niet direct in een typische expo-app (waarin geen native code is gegenereerd). We moeten native code genereren, of met andere woorden, we moeten de functie prebuild van expo gebruiken.


Conclusie

Als React Native-developer raad ik React Native MMKV van harte aan als opslagoplossing voor React Native-applicaties. De library heeft documentatie over hoe je hem integreert met andere populaire libraries voor state management, zoals jotai, redux-persist, mobx-persist en zustand-persist-middleware, waardoor je hem makkelijk in elk project kunt opnemen.

Vergeleken met React Native Async Storage biedt React Native MMKV een aantal cruciale voordelen, waaronder hoge performance, ondersteuning voor encryptie en een gebruiksvriendelijke API. Door de volledig synchrone calls, zonder async/await of Promises, is het een snellere en efficiëntere keuze.

Dus als je op zoek bent naar een betrouwbare en veilige opslagoplossing voor je React Native-app, raad ik je aan om React Native MMKV te overwegen.

Bronnen

Gepubliceerd op

Dit artikel is ook gepubliceerd op: