Uma comparação entre React Native MMKV e React Native Async Storage
Por bastante tempo, o React Native Async Storage foi a opção padrão para armazenar dados em aplicações React Native. Porém, a chegada do React-Native MMKV oferece aos desenvolvedores uma alternativa mais eficiente e avançada.
O MMKV foi criado originalmente como um framework de armazenamento chave-valor para mobile, eficiente, pequeno e fácil de usar, para o app WeChat.
Ele leva seus bindings rápidos e diretos para a biblioteca nativa em C++ à plataforma React Native por meio de uma API JavaScript simples. Hoje o React-Native MMKV é uma opção de destaque para armazenamento de dados em aplicações React Native. Uma das principais vantagens do React-Native MMKV é a performance. Como tudo é escrito em C++, ele é ~30x mais rápido que o AsyncStorage. Além disso, ele também oferece suporte a criptografia, o que o torna uma solução de armazenamento segura para o seu app. O uso de JSI em vez da "antiga" Bridge deixa tudo ainda mais rápido e eficiente.
Benchmark
https://github.com/mrousavy/react-native-mmkv#benchmark
Sem Async/Await
O React-Native MMKV também oferece chamadas totalmente síncronas, o que facilita o uso sem async/await nem Promises. Isso é o oposto do AsyncStorage, que exige comportamento assíncrono. Com o react-native-mmkv, você armazena e recupera dados facilmente com getters e setters simples. Vamos ver como inicializar o nosso storage com react-native-mmkv:
import { MMKV } from "react-native-mmkv";
export const appStorage = new MMKV({
id: "my-app-storage",
});
Recuperar dados do storage é igualmente simples, como mostrado abaixo:
// 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");
O React-Native MMKV também suporta armazenamento de objetos, o que facilita guardar estruturas de dados complexas. Veja no código a seguir:
// 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);
Remover itens do storage é igualmente fácil, como demonstrado abaixo:
// 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");
Exemplo real: Zustand middleware-persist e React Native MMKV
O React-Native MMKV pode ser integrado a bibliotecas populares de gerenciamento de estado, como jotai, redux-persist, mobx-persist e zustand-persist-middleware. Isso permite que os desenvolvedores aproveitem o armazenamento eficiente, rápido e fácil de usar do MMKV junto com as soluções de gerenciamento de estado que já usam. O resultado é uma experiência de gerenciamento de estado fluida e enxuta, que facilita gerenciar e persistir os dados da aplicação.
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),
}
)
);
O trecho de código acima mostra o uso do zustand-persist-middleware com o react-native-mmkv para controlar o tema claro/escuro do app. A combinação dessas duas bibliotecas permite persistir o estado do app, mesmo depois que o app é fechado ou reiniciado.
Declaramos um tipo personalizado, AppPersistStore, que contém a preferência de tema do app e um método para alterar essa preferência.
Em seguida, criamos uma instância do MMKV, que será usada para persistir o estado do app. Essa instância fica guardada em uma constante chamada appPersistStorage.
Depois, criamos um objeto, zustandMMKVStorage, que implementa a interface StateStorage. Esse objeto é responsável por fornecer um conjunto de métodos para interagir com a instância appPersistStorage, como definir e recuperar valores.
Por fim, usamos a função create da biblioteca zustand para criar um hook chamado useAppPersistStore, que retorna o estado atual da preferência de tema do app e um método para alterá-la. Usamos o middleware persist para garantir que o estado do app seja salvo automaticamente na instância appPersistStorage sempre que mudar.
Sempre que chamamos qualquer action dessa store, ela é persistida. Ou seja, mesmo que o app seja fechado ou reiniciado, o estado continua igual ao da última vez em que o app foi usado. Isso ajuda a oferecer uma experiência consistente ao usuário, não importa quando ou como o app é usado.
Veja abaixo como acabaríamos usando esse 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 com react-native-mmkv
Podemos usar o recurso de listeners do React Native MMKV para acompanhar mudanças no storage. Isso é útil para executar certas ações sempre que um valor específico do storage muda.
Veja um exemplo de como usar o listener em uma aplicação 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"}
/>
);
};
Neste exemplo, criamos um storage MMKV com o ID theme-preference e adicionamos um listener a ele com o método addOnValueChangedListener. O listener escuta as mudanças no storage e atualiza o tema do app de acordo.
O exemplo acima tinha a intenção de ilustrar o uso do recurso de listeners do React Native MMKV com o mínimo de código, e não de ser um exemplo realmente útil. No trecho de código, o listener é usado para escutar mudanças no storage e registrar no log os novos valores da chave alterada.
Usando com Expo
O react native mmkv é sim compatível com o expo. Porém, como ele é construído sobre módulos nativos, não vai funcionar de cara em um app expo típico (que não tem código nativo gerado). Precisamos gerar o código nativo, ou seja, precisamos usar o recurso de prebuild do expo.
Conclusão
Como desenvolvedor react native, recomendo muito o React Native MMKV como solução de armazenamento para aplicações React Native. A biblioteca tem documentação sobre como integrá-la a outras bibliotecas populares de gerenciamento de estado, como jotai, redux-persist, mobx-persist e zustand-persist-middleware, o que facilita incluí-la em qualquer projeto.
Em comparação com o React Native Async Storage, o React Native MMKV oferece várias vantagens, e vantagens cruciais, incluindo alta performance, suporte a criptografia e uma API fácil de usar. As chamadas totalmente síncronas, sem necessidade de async/await ou Promises, fazem dele uma escolha mais rápida e eficiente.
Portanto, se você procura uma solução de armazenamento confiável e segura para o seu app React Native, recomendo considerar o React Native MMKV.
Recursos
Publicado em
Este artigo também foi publicado em: