# Przestań używać React Native Async Storage

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

## Porównanie React Native MMKV i React Native Async Storage

Od dłuższego czasu React Native Async Storage był domyślnym wyborem do przechowywania danych w aplikacjach React Native. Jednak pojawienie się React-Native MMKV daje deweloperom wydajniejszą i bardziej zaawansowaną alternatywę.

MMKV powstał pierwotnie jako wydajny, mały i wygodny w użyciu mobilny framework do przechowywania danych typu klucz-wartość dla aplikacji WeChat.

Przenosi swoje szybkie, bezpośrednie bindingi do natywnej biblioteki C++ na platformę React Native przez proste API w JavaScripcie. React-Native MMKV jest dziś jedną z głównych opcji przechowywania danych w aplikacjach React Native. Jedną z kluczowych zalet React-Native MMKV jest wydajność. Ponieważ wszystko jest napisane w C++, **_jest około 30 razy szybszy niż AsyncStorage_**. Do tego obsługuje szyfrowanie, więc jest bezpiecznym rozwiązaniem do przechowywania danych w Twojej aplikacji. Użycie JSI zamiast „starego” Bridge'a dodatkowo zwiększa jego szybkość i wydajność.

### Benchmark

[**_MMKV kontra inne biblioteki do przechowywania danych: odczyt wartości ze storage'u 1000 razy.
Pomiar w milisekundach na iPhonie 11 Pro, mniej znaczy lepiej._**](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)_

### **Bez async/await**

React-Native MMKV oferuje też w pełni synchroniczne wywołania, więc łatwo go używać bez async/await i Promise'ów. To odwrotnie niż w AsyncStorage, który wymaga działania asynchronicznego. Z react-native-mmkv łatwo zapisujesz i odczytujesz dane za pomocą prostych getterów i setterów. Zobaczmy, jak zainicjalizować storage przy użyciu react-native-mmkv:

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

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

Odczyt danych ze storage'u jest równie prosty, co widać poniżej:

```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 obsługuje też przechowywanie obiektów, co ułatwia zapisywanie złożonych struktur danych. Pokazuje to poniższy kod:

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

Usuwanie elementów ze storage'u jest równie łatwe, co pokazuje poniższy przykład:

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

### Przykład z życia: middleware persist w Zustandzie i React Native MMKV

React-Native MMKV można zintegrować z popularnymi bibliotekami do zarządzania state'em, takimi jak jotai, redux-persist, mobx-persist i zustand-persist-middleware. Dzięki temu deweloperzy mogą korzystać z wydajnego, szybkiego i łatwego w użyciu storage'u MMKV razem z rozwiązaniami do zarządzania state'em, których już używają. Taka integracja daje płynne i uproszczone zarządzanie state'em, przez co łatwiej zarządzać danymi aplikacji i je utrwalać.

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

Powyższy fragment kodu pokazuje użycie zustand-persist-middleware z react-native-mmkv do obsługi jasnego i ciemnego motywu aplikacji. Połączenie tych dwóch bibliotek pozwala utrwalić state aplikacji, nawet po jej zamknięciu lub ponownym uruchomieniu.

Deklarujemy własny typ, AppPersistStore, który zawiera informację o preferowanym motywie aplikacji i metodę do zmiany tej preferencji.

Następnie tworzymy instancję MMKV, której użyjemy do utrwalania state'u aplikacji. Instancja jest zapisana w stałej o nazwie appPersistStorage.

Potem tworzymy obiekt zustandMMKVStorage, który implementuje interfejs StateStorage. Ten obiekt dostarcza zestaw metod do pracy z instancją appPersistStorage, na przykład do ustawiania i odczytywania wartości.

Na koniec używamy funkcji create z biblioteki zustand, żeby stworzyć hook o nazwie useAppPersistStore, który zwraca aktualny state preferowanego motywu aplikacji oraz metodę do zmiany tej preferencji. Używamy middleware'u persist, żeby state aplikacji był automatycznie zapisywany w instancji appPersistStorage przy każdej zmianie.

Za każdym razem, gdy wywołamy dowolną akcję z tego store'a, zostanie ona utrwalona. Oznacza to, że nawet jeśli aplikacja zostanie zamknięta lub uruchomiona ponownie, jej state pozostanie taki sam jak przy ostatnim użyciu. Pomaga to zapewnić użytkownikowi spójne doświadczenie bez względu na to, kiedy i jak korzysta z aplikacji.

Poniżej widać, jak ostatecznie użylibyśmy tego hooka:

```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;
```

### Listenery w react-native-mmkv

Możemy użyć listenerów w React Native MMKV, żeby śledzić zmiany w storage'u. Przydaje się to, gdy chcemy wykonać jakąś akcję za każdym razem, gdy zmieni się konkretna wartość w storage'u.

Oto przykład użycia listenera w aplikacji 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"}
    />
  );
};
```

W tym przykładzie stworzyliśmy storage MMKV o ID theme-preference i dodaliśmy do niego listener za pomocą metody `addOnValueChangedListener`. Listener nasłuchuje zmian w storage'u i odpowiednio aktualizuje motyw w aplikacji.

> Powyższy przykład miał zilustrować użycie listenerów w React Native MMKV przy minimalnej ilości kodu, a nie być przykładem z prawdziwego projektu. W tym fragmencie kodu listener nasłuchuje zmian w storage'u i loguje nowe wartości zmienionego klucza.

### Użycie z Expo

[React native mmkv jest kompatybilny z expo](https://github.com/mrousavy/react-native-mmkv#expo), ale ponieważ jest zbudowany na natywnych modułach, nie zadziała od razu w typowej aplikacji expo (która nie ma wygenerowanego natywnego kodu). Musimy wygenerować natywny kod, czyli innymi słowy skorzystać z funkcji [**_prebuild_**](https://docs.expo.dev/workflow/prebuild/) w expo.

---

### Podsumowanie

Jako deweloper React Native gorąco polecam React Native MMKV jako rozwiązanie do przechowywania danych w aplikacjach React Native. Biblioteka ma dokumentację opisującą integrację z innymi popularnymi bibliotekami do zarządzania state'em, takimi jak jotai, redux-persist, mobx-persist i zustand-persist-middleware, więc łatwo ją włączyć do każdego projektu.

W porównaniu z React Native Async Storage, React Native MMKV ma kilka kluczowych zalet, w tym wysoką wydajność, obsługę szyfrowania i wygodne API. W pełni synchroniczne wywołania, bez potrzeby używania async/await czy Promise'ów, sprawiają, że jest szybszym i wydajniejszym wyborem.

Dlatego jeśli szukasz niezawodnego i bezpiecznego sposobu przechowywania danych w swojej aplikacji React Native, zachęcam Cię do rozważenia React Native MMKV.

### Źródła

- [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/)

### Opublikowano na

Ten artykuł jest też opublikowany na:

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

