Flutter Mobile Development · Pelajaran

Future dan Async/Await

Pahami class `Future` milik Dart serta kata kunci `async`/`await` untuk menjalankan operasi yang tidak memblokir dan menangani hasil yang tertunda.

Pelajaran 1 dari 411 langkah

Future dan Async/Await adalah pelajaran Flutter Mobile Development gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Flutter Mobile Development, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Flutter Mobile Development mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

What is Asynchronous Code?

In app development, we often need to perform tasks that take time, like fetching data from the internet or reading a file.

If these tasks block your app's main thread, your UI becomes unresponsive and freezes. This is a bad user experience!

Asynchronous programming allows your app to start a long-running task and continue doing other things (like updating the UI) while waiting for the task to finish.

The Problem with Blocking Code

Imagine a task that takes 3 seconds. If it runs on the main thread, your app will freeze for 3 seconds. Try running this example to see how it blocks:

void main() {
  print("Starting a long task...");
  // Simulate a long-running operation
  var result = _performHeavyCalculation();
  print("Task finished with result: $result");
  print("End of program.");
}

String _performHeavyCalculation() {
  // Simulate delay without async/await
  var startTime = DateTime.now();
  while (DateTime.now().difference(startTime).inSeconds < 3) {
    // Busy-wait, blocking the thread
  }
  return "Calculated Data";
}

Meet the Dart Future

Dart's Future class is your solution for non-blocking operations. A Future represents a potential value or error that will be available at some point in the future.

It's like an IOU (I Owe You) for a value.
When you call an asynchronous function, it immediately returns a Future object.
The actual result will be delivered to the Future when the operation completes.

Think of it as ordering food; you get a receipt (the Future) immediately, but the food (the value) comes later.

Making a Simple Future

You can create a Future that completes after a delay using Future.delayed. It takes a duration and a function to execute when the delay is over.

Run this code to see how the "Data received!" message appears after a short wait, without blocking the "Program continues!" message.

void main() {
  print("Program starts!");

  Future.delayed(Duration(seconds: 2), () {
    print("Data received after 2 seconds!");
  });

  print("Program continues immediately!");
  print("End of main function.");
}

Getting Values with .then()

To actually use the value a Future eventually provides, you attach a callback function using the .then() method.

The code inside .then() will only run once the Future successfully completes and delivers its value. This is how you react to a completed async task.

void main() {
  print("Fetching user data...");

  _fetchUserData().then((userData) {
    print("User data fetched: $userData");
  });

  print("UI can update while data fetches.");
}

Future<String> _fetchUserData() {
  return Future.delayed(Duration(seconds: 2), () => "Alice (ID: 123)");
}

Handling Future Errors

Asynchronous operations can fail (e.g., network issues). To handle errors, you can chain .catchError() after .then(). This callback will execute if the Future completes with an error.

.catchError() receives the error object, allowing you to react gracefully to problems.

void main() {
  print("Attempting to fetch data...");

  _fetchFaultyData().then((data) {
    print("Data received: $data");
  }).catchError((error) {
    print("Error caught: $error");
  });
}

Future<String> _fetchFaultyData() {
  return Future.delayed(Duration(seconds: 2), () {
    throw Exception("Failed to connect to server!");
  });
}

Simplify with async and await

While .then() and .catchError() work, chaining many of them can become hard to read. Dart offers async and await keywords to make asynchronous code look and feel more like synchronous code.

async: Marks a function as asynchronous. An async function always returns a Future.
await: Can only be used inside an async function. It pauses the execution of the async function until the Future it's waiting on completes.

The rest of the program continues to run while an await is active.

Async/Await in Action

Let's rewrite our user data fetching example using async and await. Notice how much cleaner and more sequential the code looks!

The await keyword makes the code inside main appear to wait, but the main function itself is an async function, so it actually returns a Future and doesn't block the overall program.

void main() async { // main function is now async
  print("Fetching user data with async/await...");

  String userData = await _fetchUserData(); // Await the Future
  print("User data fetched: $userData");

  print("UI can update while data fetches.");
}

Future<String> _fetchUserData() {
  return Future.delayed(Duration(seconds: 2), () => "Bob (ID: 456)");
}

Try-Catch with Async/Await

With async and await, error handling becomes familiar! You can use standard try-catch blocks around await expressions to catch exceptions thrown by Futures.

This makes managing potential failures in asynchronous operations much more intuitive and readable.

void main() async {
  print("Attempting to fetch data with try-catch...");

  try {
    String data = await _fetchFaultyData();
    print("Data received: $data");
  } catch (e) {
    print("Error caught: $e");
  }
  print("Program continues after error handling.");
}

Future<String> _fetchFaultyData() {
  return Future.delayed(Duration(seconds: 2), () {
    throw Exception("Network connection lost!");
  });
}

Check Your Understanding

Consider the following Dart code snippet:

void main() async {
  print("A");
  await Future.delayed(Duration(seconds: 1), () => print("B"));
  print("C");
}

Jawab di pelajaran interaktif

Futures & Async/Await Recap

You've mastered the basics of asynchronous programming in Dart!

Future: A placeholder for a value that will be available later.
.then()/.catchError(): Methods to handle a Future's success or failure.
async: Marks a function that performs asynchronous operations and returns a Future.
await: Pauses an async function until a Future completes, making async code read like sync code.
try-catch: Used with await for robust error handling.

These tools are crucial for building responsive Flutter apps that interact with external resources. Next, we'll use these concepts to make HTTP requests!

Gratis untuk memulai

Belajar Dart dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 22
Pelajaran: 88

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Future dan Async/Await” gratis?

Ya — teks lengkap “Future dan Async/Await” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Flutter Mobile Development, upgrade ke CoddyKit PRO. Kursus Flutter Mobile Development mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Future dan Async/Await”?

Pahami class `Future` milik Dart serta kata kunci `async`/`await` untuk menjalankan operasi yang tidak memblokir dan menangani hasil yang tertunda. Kamu berlatih Flutter Mobile Development dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Flutter Mobile Development?

Tidak diperlukan pengalaman sebelumnya. Flutter Mobile Development di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “Future dan Async/Await” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Flutter Mobile Development ini?

Ya. Setiap pelajaran Flutter Mobile Development menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Flutter Mobile Development