Una comparación entre React Native MMKV y React Native Async Storage
Durante bastante tiempo, React Native Async Storage ha sido la opción por defecto para guardar datos en aplicaciones de React Native. Sin embargo, la llegada de React Native MMKV ofrece a los desarrolladores una alternativa más eficiente y avanzada.
MMKV se diseñó originalmente como un framework de almacenamiento clave-valor para móviles, eficiente, pequeño y fácil de usar, para la app WeChat.
Lleva sus bindings rápidos y directos a la librería nativa en C++ a la plataforma React Native mediante una API sencilla de JavaScript. React Native MMKV es hoy una opción destacada para el almacenamiento de datos en aplicaciones de React Native. Una de sus ventajas clave es el rendimiento. Al estar todo escrito en C++, es unas 30 veces más rápido que AsyncStorage. Además, ofrece soporte de cifrado, lo que lo convierte en una solución de almacenamiento segura para tu app. El uso de JSI en lugar del "antiguo" Bridge mejora todavía más su velocidad y eficiencia.
Benchmark
https://github.com/mrousavy/react-native-mmkv#benchmark
Sin async/await
React Native MMKV también ofrece llamadas totalmente síncronas, lo que lo hace fácil de usar sin async/await ni Promises. Esto contrasta con AsyncStorage, que exige un comportamiento asíncrono. Con react-native-mmkv puedes guardar y recuperar datos fácilmente con getters y setters simples. Veamos cómo inicializar nuestro almacenamiento con react-native-mmkv:
import { MMKV } from "react-native-mmkv";
export const appStorage = new MMKV({
id: "my-app-storage",
});
Recuperar datos del almacenamiento es igual de sencillo, como se ve a continuación:
// 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 también admite el almacenamiento de objetos, lo que facilita guardar estructuras de datos complejas. Se muestra en el siguiente código:
// 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);
Eliminar elementos del almacenamiento es igual de fácil, como se demuestra a continuación:
// 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");
Ejemplo real: middleware persist de Zustand con React Native MMKV
React Native MMKV puede integrarse con librerías populares de gestión de estado como jotai, redux-persist, mobx-persist y zustand-persist-middleware. Esto permite a los desarrolladores aprovechar el almacenamiento eficiente, rápido y fácil de usar de MMKV con sus soluciones de gestión de estado existentes. El resultado es una experiencia de gestión de estado fluida y simplificada, que facilita a los desarrolladores gestionar y persistir los datos de su aplicación.
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),
}
)
);
El fragmento de código anterior muestra el uso de zustand-persist-middleware con react-native-mmkv para manejar el tema claro/oscuro de la app. La combinación de estas dos librerías permite persistir el estado de la app, incluso después de cerrarla o reiniciarla.
Declaramos un tipo personalizado, AppPersistStore, que contiene la preferencia de tema de la app y un método para cambiar esa preferencia.
Después, creamos una instancia de MMKV, que se usará para persistir el estado de nuestra app. La instancia se guarda en una constante llamada appPersistStorage.
Luego creamos un objeto, zustandMMKVStorage, que implementa la interfaz StateStorage. Este objeto se encarga de proporcionar un conjunto de métodos que nos permiten interactuar con la instancia appPersistStorage, como fijar y recuperar valores.
Por último, usamos la función create de la librería zustand para crear un hook llamado useAppPersistStore, que devuelve el estado actual de la preferencia de tema de la app, además de un método para cambiar esa preferencia. Usamos el middleware persist para asegurarnos de que el estado de nuestra app se guarde automáticamente en la instancia appPersistStorage cada vez que cambie.
Cada vez que llamemos a cualquier acción de este store, se persistirá, lo que significa que, aunque la app se cierre o se reinicie, su estado seguirá siendo el mismo que la última vez que se usó. Esto ayuda a ofrecer una experiencia coherente al usuario, sin importar cuándo o cómo se use la app.
Así es como acabaríamos usando este hook:
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 con react-native-mmkv
Podemos usar la función de listeners de React Native MMKV para seguir los cambios en el almacenamiento. Es útil para realizar ciertas acciones cada vez que cambia un valor concreto del almacenamiento.
Aquí tienes un ejemplo de cómo usar el listener en una aplicación de 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"}
/>
);
};
En este ejemplo, hemos creado un almacenamiento MMKV con el ID theme-preference y le hemos añadido un listener con el método addOnValueChangedListener. El listener escucha los cambios en el almacenamiento y actualiza el tema de la app en consecuencia.
El ejemplo anterior pretendía ilustrar el uso de la función de listeners de React Native MMKV con la mínima cantidad de código, más que ser un ejemplo con mucho sentido. En el fragmento, el listener se usa para escuchar los cambios en el almacenamiento y mostrar por consola los nuevos valores de la clave modificada.
Uso con Expo
React Native MMKV es compatible con Expo, pero como está construido sobre módulos nativos, no funcionará de entrada en una app típica de Expo (que no tiene código nativo generado). Necesitamos generar código nativo o, dicho de otro modo, aprovechar la función prebuild de Expo.
Conclusión
Como desarrollador de React Native, recomiendo mucho React Native MMKV como solución de almacenamiento para aplicaciones de React Native. La librería ofrece documentación sobre cómo integrarla con otras librerías populares de gestión de estado como jotai, redux-persist, mobx-persist y zustand-persist-middleware, lo que facilita incorporarla a cualquier proyecto.
En comparación con React Native Async Storage, React Native MMKV ofrece varias ventajas cruciales, como un alto rendimiento, soporte de cifrado y una API fácil de usar. Sus llamadas totalmente síncronas, sin necesidad de async/await ni Promises, lo convierten en una opción más rápida y eficiente.
Por tanto, si buscas una solución de almacenamiento fiable y segura para tu app de React Native, te animo a considerar React Native MMKV.
Recursos
Publicado en
Este artículo también está publicado en: