Ein Vergleich zwischen React Native MMKV und React Native Async Storage
Lange Zeit war React Native Async Storage die erste Wahl, um Daten in React-Native-Anwendungen zu speichern. Mit React-Native MMKV haben Entwickler jetzt aber eine effizientere und fortschrittlichere Option.
MMKV wurde ursprünglich als effizientes, kleines und nutzerfreundliches Key-Value-Storage-Framework für Mobilgeräte für die App WeChat entwickelt.
Es bringt seine schnellen, direkten Bindings an die native C++-Library über eine einfache JavaScript-API auf die React-Native-Plattform. React-Native MMKV ist inzwischen eine prominente Option für die Datenspeicherung in React-Native-Anwendungen. Einer der wichtigsten Vorteile von React-Native MMKV ist die Performance. Da alles in C++ geschrieben ist, ist es etwa 30x schneller als AsyncStorage. Außerdem unterstützt es Verschlüsselung und ist damit eine sichere Storage-Lösung für deine App. Die Nutzung von JSI statt der "alten" Bridge steigert Geschwindigkeit und Effizienz zusätzlich.
Benchmark
https://github.com/mrousavy/react-native-mmkv#benchmark
Kein Async/Await
React-Native MMKV bietet außerdem vollständig synchrone Aufrufe, sodass es sich ohne async/await oder Promises einfach nutzen lässt. Das ist ein Unterschied zu AsyncStorage, das asynchrones Verhalten erfordert. Mit react-native-mmkv kannst du Daten über einfache Getter und Setter speichern und abrufen. Schauen wir uns an, wie wir unseren Storage mit react-native-mmkv initialisieren:
import { MMKV } from "react-native-mmkv";
export const appStorage = new MMKV({
id: "my-app-storage",
});
Daten aus dem Storage abzurufen ist genauso einfach, wie unten gezeigt:
// 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 unterstützt auch das Speichern von Objekten, sodass sich komplexe Datenstrukturen leicht ablegen lassen. Das zeigt der folgende 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);
Einträge aus dem Storage zu entfernen ist ebenso einfach, wie unten demonstriert:
// 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");
Ein Beispiel aus der Praxis: Zustand middleware-persist und React Native MMKV
React-Native MMKV lässt sich mit beliebten State-Management-Libraries wie jotai, redux-persist, mobx-persist und zustand-persist-middleware integrieren. So können Entwickler die effizienten, schnellen und einfach nutzbaren Storage-Fähigkeiten von MMKV mit ihren bestehenden State-Management-Lösungen kombinieren. Das Ergebnis ist ein nahtloses und schlankes State-Management, mit dem Entwickler ihre Anwendungsdaten leichter verwalten und persistieren können.
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),
}
)
);
Das Snippet oben zeigt, wie zustand-persist-middleware zusammen mit react-native-mmkv das helle/dunkle Theme der App verwaltet. Durch die Kombination dieser beiden Libraries lässt sich der State der App persistieren, selbst nachdem die App geschlossen oder neu gestartet wurde.
Wir deklarieren einen eigenen Typ, AppPersistStore, der Informationen über die Theme-Präferenz der App und eine Methode zum Ändern dieser Präferenz enthält.
Als Nächstes erstellen wir eine MMKV-Instanz, mit der der State unserer App persistiert wird. Die Instanz wird in einer Konstante namens appPersistStorage gespeichert.
Dann erstellen wir ein Objekt, zustandMMKVStorage, das das Interface StateStorage implementiert. Dieses Objekt stellt eine Reihe von Methoden bereit, mit denen wir mit der Instanz appPersistStorage interagieren können, etwa um Werte zu setzen und abzurufen.
Schließlich nutzen wir die Funktion create aus der Library zustand, um einen Hook namens useAppPersistStore zu erstellen, der den aktuellen State der Theme-Präferenz der App sowie eine Methode zum Ändern dieser Präferenz zurückgibt. Mit der Middleware persist sorgen wir dafür, dass der State unserer App bei jeder Änderung automatisch in der Instanz appPersistStorage gespeichert wird.
Jedes Mal, wenn wir eine Action aus diesem Store aufrufen, wird sie persistiert. Selbst wenn die App geschlossen oder neu gestartet wird, bleibt der State der App also genau so, wie er bei der letzten Nutzung war. Das sorgt für eine konsistente Erfahrung für den Nutzer, egal wann oder wie die App verwendet wird.
So würden wir diesen Hook am Ende verwenden:
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;
Listener mit react-native-mmkv
Mit der Listener-Funktion von React Native MMKV können wir Änderungen im Storage verfolgen. Das ist nützlich, um bestimmte Aktionen auszuführen, sobald sich ein bestimmter Wert im Storage ändert.
Hier ein Beispiel, wie wir den Listener in einer React-Native-Anwendung verwenden können:
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 diesem Beispiel haben wir einen MMKV-Storage mit der ID theme-preference erstellt und ihm mit der Methode addOnValueChangedListener einen Listener hinzugefügt. Der Listener achtet auf Änderungen im Storage und aktualisiert das Theme in der App entsprechend.
Das Beispiel oben soll die Nutzung der Listener-Funktion in React Native MMKV mit möglichst wenig Code veranschaulichen und kein besonders sinnvolles Beispiel sein. Im Snippet hört der Listener auf Änderungen im Storage und loggt die neuen Werte des geänderten Keys.
Verwendung mit Expo
React Native MMKV ist tatsächlich mit Expo kompatibel, aber da es auf nativen Modulen aufbaut, funktioniert es in einer typischen Expo-App (ohne generierten nativen Code) nicht direkt. Wir müssen nativen Code generieren, oder anders gesagt, das Feature prebuild von Expo nutzen.
Fazit
Als React-Native-Entwickler kann ich React Native MMKV als Storage-Lösung für React-Native-Anwendungen sehr empfehlen. Die Library bietet Dokumentation zur Integration mit anderen beliebten State-Management-Libraries wie jotai, redux-persist, mobx-persist und zustand-persist-middleware, sodass sie sich leicht in jedes Projekt einbauen lässt.
Im Vergleich zu React Native Async Storage bietet React Native MMKV mehrere entscheidende Vorteile, darunter hohe Performance, Unterstützung für Verschlüsselung und eine nutzerfreundliche API. Die vollständig synchronen Aufrufe ohne async/await oder Promises machen es zu einer schnelleren und effizienteren Wahl.
Wenn du also eine zuverlässige und sichere Storage-Lösung für deine React-Native-App suchst, empfehle ich dir, React Native MMKV in Betracht zu ziehen.
Ressourcen
Veröffentlicht auf
Dieser Artikel ist auch erschienen auf: