Blogg

Sluta använda React Native Async Storage

10 februari 2023 6 min läsning

Varför du bör lämna React Native Async Storage och vad moderna alternativ som MMKV erbjuder när det gäller prestanda och säkerhet.

Sluta använda React Native Async Storage
React NativeAsync StorageAsyncStorageMMKVLagringSäkerhetPrestanda

En jämförelse mellan React Native MMKV och React Native Async Storage

Länge har React Native Async Storage varit förstahandsvalet för att lagra data i React Native-appar. Men med React-Native MMKV får utvecklare ett effektivare och mer avancerat alternativ.

MMKV utvecklades ursprungligen som ett effektivt, litet och lättanvänt ramverk för key-value-lagring i mobilen för appen WeChat.

Det tar sina snabba, direkta bindningar till det nativa C++-biblioteket till React Native-plattformen via ett enkelt JavaScript-API. React-Native MMKV är nu ett framträdande alternativ för datalagring i React Native-appar. En av de största fördelarna med React-Native MMKV är prestandan. Eftersom allt är skrivet i C++ är det ~30 gånger snabbare än AsyncStorage. Dessutom stöder det kryptering, vilket gör det till en säker lagringslösning för din app. Att det använder JSI i stället för den "gamla" Bridge gör det ännu snabbare och effektivare.

Benchmark

MMKV jämfört med andra lagringsbibliotek: läsa ett värde från lagringen 1000 gånger. Mätt i millisekunder på en iPhone 11 Pro, lägre är bättre.

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

Ingen async/await

React-Native MMKV erbjuder dessutom helt synkrona anrop, så det är enkelt att använda utan async/await eller Promises. Det skiljer sig från AsyncStorage, som kräver asynkront beteende. Med react-native-mmkv kan du enkelt spara och hämta data med enkla getters och setters. Så här kan vi initiera vår lagring med react-native-mmkv:

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

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

Att hämta data från lagringen är lika enkelt, som du ser nedan:

// 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 stöder också lagring av objekt, så det är enkelt att spara komplexa datastrukturer. Det visas i följande kod:

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

Att ta bort poster från lagringen är lika enkelt, som du ser nedan:

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

Exempel från verkligheten: Zustand middleware-persist och React Native MMKV

React-Native MMKV kan integreras med populära bibliotek för state management som jotai, redux-persist, mobx-persist och zustand-persist-middleware. Det gör att utvecklare kan dra nytta av MMKV:s effektiva, snabba och lättanvända lagring tillsammans med sina befintliga lösningar för state management. Resultatet är en smidig och strömlinjeformad state management, som gör det lättare för utvecklare att hantera och spara appens data.

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

Kodsnutten ovan visar hur zustand-persist-middleware används med react-native-mmkv för att hantera appens ljusa/mörka tema. Kombinationen av de två biblioteken gör det möjligt att spara appens state även efter att appen har stängts eller startats om.

Vi deklarerar en egen typ, AppPersistStore, som innehåller information om appens temaval och en metod för att ändra det valet.

Sedan skapar vi en MMKV-instans som används för att spara appens state. Instansen lagras i en konstant som heter appPersistStorage.

Därefter skapar vi ett objekt, zustandMMKVStorage, som implementerar gränssnittet StateStorage. Objektet ansvarar för att tillhandahålla ett antal metoder som låter oss arbeta med instansen appPersistStorage, till exempel för att sätta och hämta värden.

Till sist använder vi funktionen create från biblioteket zustand för att skapa en hook som heter useAppPersistStore. Den returnerar det aktuella state för appens temaval och en metod för att ändra valet. Vi använder middlewaren persist för att se till att appens state automatiskt sparas till instansen appPersistStorage varje gång state ändras.

Varje gång vi anropar en action från den här storen sparas den. Det betyder att även om appen stängs eller startas om är appens state detsamma som när appen senast användes. Det ger användaren en konsekvent upplevelse, oavsett när eller hur appen används.

Så här skulle vi till slut använda den här hooken:

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;

Lyssnare med react-native-mmkv

Vi kan använda lyssnarfunktionen i React Native MMKV för att följa ändringar i lagringen. Det är användbart när vi vill utföra vissa handlingar varje gång ett visst värde i lagringen ändras.

Här är ett exempel på hur vi kan använda lyssnaren i en React Native-app:

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

I det här exemplet har vi skapat en MMKV-lagring med ID:t theme-preference och lagt till en lyssnare med metoden addOnValueChangedListener. Lyssnaren lyssnar efter ändringar i lagringen och uppdaterar temat i appen därefter.

Exemplet ovan var tänkt att illustrera hur lyssnarfunktionen i React Native MMKV används med så lite kod som möjligt, snarare än att vara ett meningsfullt exempel. I kodsnutten används lyssnaren för att lyssna efter ändringar i lagringen och logga de nya värdena för den ändrade nyckeln.

Använda med Expo

React native mmkv är faktiskt kompatibelt med expo, men eftersom det bygger på native-moduler fungerar det inte direkt i en vanlig expo-app (där ingen native-kod genereras). Vi behöver generera native-kod, eller med andra ord använda funktionen prebuild i expo.


Slutsats

Som react native-utvecklare rekommenderar jag varmt React Native MMKV som lagringslösning för React Native-appar. Biblioteket har dokumentation om hur man integrerar det med andra populära bibliotek för state management som jotai, redux-persist, mobx-persist och zustand-persist-middleware, vilket gör det lätt att använda i vilket projekt som helst.

Jämfört med React Native Async Storage har React Native MMKV flera avgörande fördelar, bland annat hög prestanda, stöd för kryptering och ett användarvänligt API. De helt synkrona anropen, utan behov av async/await eller Promises, gör det till ett snabbare och effektivare val.

Så om du letar efter en pålitlig och säker lagringslösning för din React Native-app vill jag uppmuntra dig att överväga React Native MMKV.

Resurser

Publicerad på

Den här artikeln är också publicerad på: