# Smetti di usare React Native Async Storage

By Tarik Pinarci (https://tarikpinarci.com). Published 2023-02-10. Canonical: https://tarikpinarci.com/it/blog/stop-using-react-native-async-storage

## Un confronto tra React Native MMKV e React Native Async Storage

Per parecchio tempo React Native Async Storage è stata la scelta standard per salvare dati nelle applicazioni React Native. Con l'arrivo di React-Native MMKV, però, gli sviluppatori hanno a disposizione un'opzione più efficiente e avanzata.

MMKV è nato come framework di storage chiave valore per mobile, efficiente, piccolo e facile da usare, pensato per l'app WeChat.

Porta sulla piattaforma React Native i suoi binding veloci e diretti alla libreria nativa C++ tramite una semplice API JavaScript. React-Native MMKV oggi è un'opzione di primo piano per salvare dati nelle applicazioni React Native. Uno dei suoi vantaggi principali sono le prestazioni. Dato che è tutto scritto in C++, **_è circa 30 volte più veloce di AsyncStorage_**. Offre anche il supporto alla crittografia, il che lo rende una soluzione di storage sicura per la tua app. L'uso di JSI al posto del "vecchio" Bridge ne aumenta ancora velocità ed efficienza.

### Benchmark

[**_MMKV contro altre librerie di storage: lettura di un valore dallo storage 1000 volte.
Misurato in millisecondi su un iPhone 11 Pro, più basso è meglio._**](https://github.com/mrousavy/react-native-mmkv#benchmark)

![[https://github.com/mrousavy/react-native-mmkv#benchmark](https://github.com/mrousavy/react-native-mmkv#benchmark)](https://cdn-images-1.medium.com/max/2000/1*v6sX7AfLoqGWl6nK6XoneA.png)_[https://github.com/mrousavy/react-native-mmkv#benchmark](https://github.com/mrousavy/react-native-mmkv#benchmark)_

### **Niente async/await**

React-Native MMKV offre anche chiamate completamente sincrone, quindi si usa facilmente senza async/await o Promise. AsyncStorage invece richiede un comportamento asincrono. Con react-native-mmkv puoi salvare e leggere dati con semplici getter e setter. Vediamo come inizializzare lo storage con react-native-mmkv:

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

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

Anche leggere i dati dallo storage è altrettanto semplice, come si vede qui sotto:

```tsx
// 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 supporta anche il salvataggio di oggetti, così è facile salvare strutture dati complesse. Lo mostra il codice seguente:

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

Anche rimuovere elementi dallo storage è semplicissimo, come dimostrato qui sotto:

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

### Esempio reale: middleware persist di Zustand e React Native MMKV

React-Native MMKV si integra con librerie di state management molto diffuse come jotai, redux-persist, mobx-persist e zustand-persist-middleware. Così gli sviluppatori possono sfruttare lo storage efficiente, veloce e facile da usare di MMKV insieme alle soluzioni di state management che già usano. Il risultato è una gestione dello state fluida e ordinata, che rende più semplice gestire e rendere persistenti i dati dell'applicazione.

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

Lo snippet qui sopra mostra l'uso di zustand-persist-middleware con react-native-mmkv per gestire il tema chiaro/scuro dell'app. La combinazione di queste due librerie permette di rendere persistente lo state dell'app, anche dopo che l'app è stata chiusa o riavviata.

Dichiariamo un tipo personalizzato, AppPersistStore, che contiene la preferenza del tema dell'app e un metodo per cambiarla.

Poi creiamo un'istanza di MMKV, che useremo per rendere persistente lo state della nostra app. L'istanza è salvata in una costante chiamata appPersistStorage.

Quindi creiamo un oggetto, zustandMMKVStorage, che implementa l'interfaccia StateStorage. Questo oggetto fornisce una serie di metodi per interagire con l'istanza appPersistStorage, come salvare e leggere valori.

Infine usiamo la funzione create della libreria zustand per creare un hook chiamato useAppPersistStore, che restituisce lo state attuale della preferenza del tema e un metodo per cambiarla. Usiamo il middleware persist per fare in modo che lo state dell'app venga salvato automaticamente nell'istanza appPersistStorage ogni volta che cambia.

Ogni volta che chiamiamo un'azione di questo store, il risultato viene reso persistente: anche se l'app viene chiusa o riavviata, il suo state resterà quello dell'ultimo utilizzo. Questo aiuta a offrire all'utente un'esperienza coerente, indipendentemente da quando o come usa l'app.

Ecco come useremmo alla fine questo hook:

```tsx
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 con react-native-mmkv

Possiamo usare la funzione di listener di React Native MMKV per seguire le modifiche nello storage. È utile per eseguire certe azioni ogni volta che cambia un determinato valore nello storage.

Ecco un esempio di come usare il listener in un'applicazione React Native:

```tsx
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 questo esempio abbiamo creato uno storage MMKV con l'ID theme-preference e gli abbiamo aggiunto un listener con il metodo `addOnValueChangedListener`. Il listener ascolta le modifiche nello storage e aggiorna di conseguenza il tema dell'app.

> L'esempio qui sopra voleva mostrare l'uso del listener in React Native MMKV con il minimo di codice, non essere un esempio significativo. Nello snippet il listener ascolta le modifiche nello storage e stampa nel log i nuovi valori della chiave modificata.

### Usarlo con Expo

[React native mmkv è compatibile con expo](https://github.com/mrousavy/react-native-mmkv#expo), ma dato che si basa su moduli nativi, non funziona così com'è in una tipica app expo (che non ha codice nativo generato). Dobbiamo generare il codice nativo, in altre parole dobbiamo sfruttare la funzione [**_prebuild_**](https://docs.expo.dev/workflow/prebuild/) di expo.

---

### Conclusione

Da sviluppatore react native, consiglio vivamente React Native MMKV come soluzione di storage per le applicazioni React Native. La libreria spiega nella documentazione come integrarla con altre librerie di state management diffuse come jotai, redux-persist, mobx-persist e zustand-persist-middleware, quindi è facile inserirla in qualsiasi progetto.

Rispetto a React Native Async Storage, React Native MMKV offre diversi vantaggi decisivi, tra cui prestazioni elevate, supporto alla crittografia e un'API facile da usare. Le sue chiamate completamente sincrone, senza bisogno di async/await o Promise, lo rendono una scelta più veloce ed efficiente.

Quindi, se cerchi una soluzione di storage affidabile e sicura per la tua app React Native, ti consiglio di prendere in considerazione React Native MMKV.

### Risorse

- [https://github.com/mrousavy/react-native-mmkv](https://github.com/mrousavy/react-native-mmkv)

- [https://react-native-async-storage.github.io/async-storage/](https://react-native-async-storage.github.io/async-storage/)

### Pubblicato su

Questo articolo è pubblicato anche su:

- [Medium](https://medium.com/gitconnected/stop-using-react-native-async-storage-fdbcc05a6de3)

