# Berhenti Memakai React Native Async Storage

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

## Perbandingan React Native MMKV dan React Native Async Storage

Sudah cukup lama React Native Async Storage menjadi pilihan utama untuk menyimpan data di aplikasi React Native. Namun, hadirnya React-Native MMKV memberi developer pilihan yang lebih efisien dan lebih canggih.

MMKV awalnya dirancang sebagai framework penyimpanan key-value mobile yang efisien, kecil, dan mudah dipakai untuk aplikasi WeChat.

Library ini membawa binding langsung yang cepat ke library C++ native ke platform React Native melalui API JavaScript yang sederhana. React-Native MMKV kini menjadi pilihan utama untuk penyimpanan data di aplikasi React Native. Salah satu keunggulan utama React-Native MMKV adalah performanya. Karena semuanya ditulis dalam C++, **_library ini sekitar 30x lebih cepat daripada AsyncStorage_**. Selain itu, library ini juga mendukung enkripsi, sehingga menjadi solusi penyimpanan yang aman untuk aplikasimu. Penggunaan JSI alih-alih Bridge yang “lama” semakin meningkatkan kecepatan dan efisiensinya.

### Benchmark

[**_MMKV dibandingkan library penyimpanan lain: membaca satu nilai dari Storage sebanyak 1000 kali.
Diukur dalam milidetik di iPhone 11 Pro, makin rendah makin baik._**](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)_

### **Tanpa Async/Await**

React-Native MMKV juga menyediakan pemanggilan yang sepenuhnya sinkron, sehingga mudah dipakai tanpa async/await atau Promise. Ini berbeda dengan AsyncStorage, yang mengharuskan perilaku asinkron. Dengan react-native-mmkv, kamu bisa menyimpan dan mengambil data dengan mudah memakai getter dan setter sederhana. Mari kita lihat cara menginisialisasi storage dengan react-native-mmkv:

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

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

Mengambil data dari storage juga sama mudahnya, seperti di bawah ini:

```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 juga mendukung penyimpanan objek, sehingga struktur data yang kompleks mudah disimpan. Contohnya bisa dilihat pada kode berikut:

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

Menghapus item dari storage juga sama mudahnya, seperti yang ditunjukkan di bawah:

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

### Contoh nyata: middleware persist Zustand dan React Native MMKV

React-Native MMKV bisa diintegrasikan dengan library state management populer seperti jotai, redux-persist, mobx-persist, dan zustand-persist-middleware. Dengan begitu, developer bisa memanfaatkan kemampuan penyimpanan MMKV yang efisien, cepat, dan mudah dipakai bersama solusi state management yang sudah mereka gunakan. Hasilnya adalah pengalaman state management yang mulus dan ringkas, sehingga developer lebih mudah mengelola dan menyimpan data aplikasi mereka secara persisten.

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

Potongan kode di atas menunjukkan penggunaan zustand-persist-middleware bersama react-native-mmkv untuk menangani tema terang/gelap aplikasi. Kombinasi kedua library ini memungkinkan state aplikasi tetap tersimpan, bahkan setelah aplikasi ditutup atau dijalankan ulang.

Kita mendeklarasikan tipe kustom, AppPersistStore, yang berisi informasi preferensi tema aplikasi dan sebuah method untuk mengubah preferensi tersebut.

Selanjutnya, kita membuat instance MMKV yang akan dipakai untuk menyimpan state aplikasi secara persisten. Instance ini disimpan dalam konstanta bernama appPersistStorage.

Lalu kita membuat objek zustandMMKVStorage yang mengimplementasikan interface StateStorage. Objek ini bertugas menyediakan sekumpulan method untuk berinteraksi dengan instance appPersistStorage, seperti menyimpan dan mengambil nilai.

Terakhir, kita memakai fungsi create dari library zustand untuk membuat hook bernama useAppPersistStore, yang mengembalikan state preferensi tema aplikasi saat ini, beserta method untuk mengubah preferensi tersebut. Kita memakai middleware persist untuk memastikan state aplikasi otomatis tersimpan ke instance appPersistStorage setiap kali state berubah.

Setiap kali kita memanggil action apa pun dari store ini, hasilnya akan disimpan secara persisten. Artinya, walaupun aplikasi ditutup atau dijalankan ulang, state aplikasi tetap sama seperti saat terakhir kali aplikasi dipakai. Ini membantu memberi pengalaman yang konsisten bagi pengguna, kapan pun dan bagaimanapun aplikasi dipakai.

Berikut cara kita akhirnya memakai hook ini:

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

Kita bisa memakai fitur listener dari React Native MMKV untuk melacak perubahan di storage. Ini berguna untuk menjalankan aksi tertentu setiap kali nilai tertentu di storage berubah.

Berikut contoh penggunaan listener di aplikasi 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"}
    />
  );
};
```

Pada contoh ini, kita membuat storage MMKV dengan ID theme-preference dan menambahkan listener padanya memakai method `addOnValueChangedListener`. Listener ini mendengarkan perubahan di storage dan memperbarui tema aplikasi sesuai perubahan tersebut.

> Contoh di atas dimaksudkan untuk menggambarkan penggunaan fitur listener di React Native MMKV dengan kode seminimal mungkin, bukan sebagai contoh yang benar-benar bermakna. Dalam potongan kode tersebut, listener dipakai untuk mendengarkan perubahan di storage dan mencatat nilai baru dari key yang berubah.

### Memakai dengan Expo

[React native mmkv memang kompatibel dengan expo](https://github.com/mrousavy/react-native-mmkv#expo), tetapi karena dibangun di atas native module, library ini tidak akan langsung berjalan di aplikasi expo biasa (yang tidak punya kode native yang di-generate). Kita perlu men-generate kode native, atau dengan kata lain, kita perlu memanfaatkan fitur [**_prebuild_**](https://docs.expo.dev/workflow/prebuild/) dari expo.

---

### Kesimpulan

Sebagai developer react native, saya sangat merekomendasikan React Native MMKV sebagai solusi penyimpanan untuk aplikasi React Native. Library ini menyediakan dokumentasi tentang cara mengintegrasikannya dengan library state management populer lain seperti jotai, redux-persist, mobx-persist, dan zustand-persist-middleware, sehingga mudah dipasang di proyek apa pun.

Dibandingkan React Native Async Storage, React Native MMKV menawarkan beberapa keunggulan yang krusial, termasuk performa tinggi, dukungan enkripsi, dan API yang mudah dipakai. Pemanggilannya yang sepenuhnya sinkron, tanpa perlu async/await atau Promise, menjadikannya pilihan yang lebih cepat dan efisien.

Jadi, jika kamu mencari solusi penyimpanan yang andal dan aman untuk aplikasi React Native, saya menyarankan kamu mempertimbangkan React Native MMKV.

### Sumber

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

### Diterbitkan di

Artikel ini juga diterbitkan di:

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

