Tutorial Dart: Memahami Asynchronous dan penggunaan Future

Pada bahasa pemrograman Dart, Future adalah salah satu cara yang digunakan untuk menangani operasi asynchronous, yaitu operasi yang butuh waktu untuk menyelesaikan, seperti mengambil data dari internet atau membaca file besar. Jika kamu sering menggunakan Flutter atau Dart, pasti sering menemui istilah Future. Jadi, mari kita bongkar apa itu Future, statusnya, serta bagaimana menggunakannya dengan cara yang mudah dipahami.

Apa Itu Future?

Secara sederhana, Future adalah objek yang merepresentasikan hasil dari suatu operasi yang belum selesai saat ini, tetapi akan selesai di masa depan (future). Ketika kamu menjalankan operasi seperti HTTP request atau database query, operasi tersebut akan berjalan di background dan mengembalikan objek Future. Jadi, kamu bisa melakukan hal lain sembari menunggu hasilnya.

Synchronous vs. Asynchronous: Apa Bedanya?

Sebelum kita masuk lebih dalam tentang Future, penting untuk memahami konsep synchronous dan asynchronous, karena ini adalah dasar dari bagaimana Future bekerja.

• Synchronous (Sinkron): Dalam pemrograman sinkron, setiap perintah dijalankan secara berurutan, satu per satu. Artinya, jika ada satu perintah yang memakan waktu lama, program akan menunggu perintah itu selesai sebelum melanjutkan ke perintah berikutnya. Ini seperti antrian di kasir: kamu harus menunggu pelanggan di depanmu selesai sebelum kamu dilayani. Contoh sederhana:

  void main() {
    print('Proses 1 dimulai');
    print('Proses 2 dimulai');
  }
  

  Kode di atas akan mengeksekusi Proses 1 dulu, baru Proses 2.

• Asynchronous (Asinkron): Dalam pemrograman asinkron, beberapa perintah bisa dijalankan di background, tanpa harus menunggu perintah sebelumnya selesai. Ini seperti ketika kamu memesan makanan dan menunggu pesananmu disiapkan sambil melakukan hal lain. Program tidak akan "macet" menunggu operasi yang memakan waktu selesai. Contoh menggunakan Future:

  Future<void> main() async {
    print('Proses 1 dimulai');
    await Future.delayed(Duration(seconds: 2)); // Operasi yang memakan waktu
    print('Proses 2 dimulai');
  }
  

  Di sini, meskipun ada jeda waktu 2 detik untuk menunggu, program tidak berhenti secara keseluruhan.

Perbedaan Utama

• Synchronous: Eksekusi terjadi secara berurutan, satu operasi harus selesai sebelum melanjutkan ke operasi berikutnya. Ini bisa membuat aplikasi terasa lambat jika ada operasi yang memakan waktu.
• Asynchronous: Operasi yang memakan waktu dapat berjalan di background, sehingga aplikasi tidak terhenti. Ini membuat aplikasi lebih responsif dan interaktif.

Status Future

1. Uncompleted: Ketika operasi asynchronous baru dimulai, Future berada di status "belum selesai" alias uncompleted. Pada saat ini, kita belum tahu hasilnya apa, dan operasi masih berjalan di background.

2. Completed with Data (Success): Jika operasi selesai dengan sukses, status Future akan menjadi completed dan akan memiliki nilai (data yang dikembalikan). Misalnya, jika kamu mengambil data dari internet, data tersebut akan dikembalikan saat operasi selesai.

3. Completed with Error (Failed): Di sisi lain, jika terjadi error selama operasi, Future tetap dianggap completed, tetapi dengan error, bukan data.

Cara Menggunakan Future

Sekarang, mari kita lihat dua cara umum untuk menangani Future di Dart: menggunakan then dan async-await.

1. Menggunakan then()

Cara ini sedikit lebih lama dan klasik untuk menangani Future. Setelah operasi selesai, kita bisa menangkap hasilnya menggunakan method then(). Ini bekerja seperti callback, di mana kamu memberikan fungsi yang akan dipanggil saat Future sudah selesai.

Contoh penggunaan then():

Future<int> fetchData() {
  return Future.delayed(Duration(seconds: 2), () {
    return 42; // data yang diambil setelah 2 detik
  });
}

void main() {
  fetchData().then((data) {
    print('Data yang diterima: $data');
  }).catchError((error) {
    print('Terjadi kesalahan: $error');
  });
}

Pada contoh di atas, fetchData() adalah operasi asynchronous yang membutuhkan 2 detik untuk selesai. Saat data sudah tersedia, then() akan menangkap hasilnya dan mencetaknya. Jika terjadi error, kita bisa menangkapnya dengan catchError().

2. Menggunakan async-await

async-await adalah cara yang lebih modern dan lebih bersih untuk menangani Future di Dart. Dengan async-await, kode kita terlihat seperti kode synchronous (berjalan berurutan), tetapi sebenarnya asynchronous.

Contoh penggunaan async-await:

Future<int> fetchData() async {
  await Future.delayed(Duration(seconds: 2)); // tunggu 2 detik
  return 42; // data yang dikembalikan setelah 2 detik
}

void main() async {
  try {
    var data = await fetchData();
    print('Data yang diterima: $data');
  } catch (error) {
    print('Terjadi kesalahan: $error');
  }
}

Perhatikan perbedaan utamanya di sini: kita menggunakan kata kunci await untuk "menunggu" operasi selesai, dan hasilnya disimpan dalam variabel data. Jika terjadi error, kita bisa menangkapnya menggunakan try-catch. Ini membuat kode lebih mudah dibaca karena urutan kodenya jelas.

Penggunaan finally dan whenComplete()

Dalam beberapa kasus, kamu mungkin ingin mengeksekusi suatu kode setelah operasi selesai, baik berhasil atau gagal. Dart menyediakan dua cara untuk melakukan ini: menggunakan finally atau whenComplete().

• finally: Dalam blok try-catch-finally, kode di dalam finally akan selalu dijalankan, tidak peduli apakah ada error atau tidak.

  Contoh penggunaan finally:

  void main() async {
    try {
      var data = await fetchData();
      print('Data yang diterima: $data');
    } catch (error) {
      print('Terjadi kesalahan: $error');
    } finally {
      print('Operasi selesai');
    }
  }
  

  Pada contoh ini, pesan "Operasi selesai" akan dicetak terlepas dari apakah operasi berhasil atau gagal.

• whenComplete(): Alternatif lain untuk finally dalam Future adalah method whenComplete(), yang fungsinya hampir sama dengan finally. Method ini dipanggil setelah operasi selesai, baik itu berhasil atau gagal.

  Contoh penggunaan whenComplete():

  fetchData().then((data) {
    print('Data yang diterima: $data');
  }).catchError((error) {
    print('Terjadi kesalahan: $error');
  }).whenComplete(() {
    print('Operasi selesai');
  });
  

  Di sini, whenComplete() akan dijalankan setelah then() atau catchError() dieksekusi, memastikan bahwa kode selalu dijalankan di akhir.

Perbedaan antara then() dan async-await

1. Keterbacaan: async-await lebih mudah dibaca dan ditulis dibandingkan then(). Kodenya terlihat lebih bersih dan urutan eksekusinya lebih mudah dipahami. Sementara then() menggunakan callback, yang kadang bisa menjadi membingungkan, terutama jika ada banyak callback berlapis-lapis (callback hell).

2. Error Handling: Dengan then(), kamu menggunakan catchError() untuk menangkap error, sedangkan di async-await, kamu bisa menggunakan try-catch, yang lebih rapi dan mudah dimengerti.

3. Struktur: then() lebih cocok untuk kasus-kasus sederhana atau operasi kecil, sementara async-await lebih fleksibel dan direkomendasikan untuk operasi yang lebih kompleks karena strukturnya lebih mudah di-maintain.

Penutup

• Future digunakan untuk menangani operasi asynchronous di Dart.
• Status Future bisa uncompleted, completed with data, atau completed with error.
• Ada dua cara utama untuk menangani Future: dengan then() atau dengan async-await.
• async-await biasanya lebih disarankan karena kode lebih bersih, mudah dibaca, dan error handling lebih simpel dengan try-catch.
• Kamu bisa menggunakan finally atau whenComplete() untuk mengeksekusi kode setelah operasi selesai, baik berhasil maupun gagal.

Semoga sekarang kamu lebih paham tentang Future dan bagaimana cara menggunakannya di Dart. Kalau kamu masih bingung, jangan ragu untuk eksplorasi lebih lanjut, dan pastikan praktik langsung biar semakin mahir!🔥😊

Baca juga :