Blog

Pare de usar o React Native Async Storage

10 de fevereiro de 2023 6 min de leitura

Por que você deveria deixar o React Native Async Storage de lado e o que alternativas modernas como o MMKV oferecem em performance e segurança.

Pare de usar o React Native Async Storage
React NativeAsync StorageAsyncStorageMMKVArmazenamentoSegurançaPerformance

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

MMKV vs outras bibliotecas de armazenamento: lendo um valor do Storage 1000 vezes. Medido em milissegundos em um iPhone 11 Pro, quanto menor, melhor.

https://github.com/mrousavy/react-native-mmkv#benchmarkhttps://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: