Aplikasi Flutter terus-menerus menangani operasi asynchronous (permintaan jaringan, akses file, kueri database). Futures Dart (hasil async tunggal) dan Streams (urutan peristiwa async), bersama dengan async/await dan widget seperti FutureBuilder/StreamBuilder, sangat penting untuk UI async.
// a Future represents a single async result that completes later
Future<String> fetchUser() async {
final response = await http.get(url); // await pauses until the Future completes
return response.body; // returns the result
}
// using it
final data = await fetchUser(); // await the result
// or: fetchUser().then((data) => ...); // callback style
Future = nilai tunggal yang tersedia nanti (respons jaringan, pembacaan file). async/await membuat kode async dibaca secara berurutan.
// FutureBuilder rebuilds the UI based on the Future's state (loading/data/error)
FutureBuilder<String>(
future: fetchUser(),
builder: (context, snapshot) {
if (snapshot.connectionState == ConnectionState.waiting) {
return CircularProgressIndicator(); // loading
} else if (snapshot.hasError) {
return Text('Error: ${snapshot.error}'); // error
} else {
return Text(snapshot.data!); // got the data
}
},
)
// a Stream = a SEQUENCE of async events over time (e.g. live data, websocket, sensor)
Stream<int> counter() async* {
for (int i = 0; i < 10; i++) {
await Future.delayed(Duration(seconds: 1));
yield i; // emit each value
}
}
// StreamBuilder rebuilds the UI as new events arrive
StreamBuilder<int>(stream: counter(), builder: (context, snapshot) => Text('${snapshot.data}'))
Memahami async, Futures, dan Streams sangat penting karena aplikasi Flutter terus-menerus berurusan dengan operasi asynchronous, jadi menanganinya dengan benar adalah fondasi untuk membangun aplikasi nyata.
Hampir setiap aplikasi melakukan pekerjaan async — permintaan jaringan, akses file, kueri database, data real-time — dan primitif async Dart adalah cara Anda menanganinya.
Memahami Futures (mewakili hasil async tunggal yang tersedia nanti, seperti respons jaringan) dengan async/await (membuat kode async dibaca secara berurutan dan bersih) sangat penting untuk melakukan operasi async.
Memahami FutureBuilder sangat penting untuk UI: membangun UI berdasarkan status Future, menangani status loading, error, dan data dengan benar — yang persis seperti yang aplikasi nyata butuhkan (menampilkan spinner saat loading, pesan error saat gagal, dan data saat berhasil), pola umum dan penting untuk UI async.
Memahami Streams (urutan peristiwa async dari waktu ke waktu, seperti data live, websockets, atau pembacaan sensor) dan StreamBuilder (membangun ulang UI saat peristiwa baru tiba) sangat penting untuk UI reaktif dan real-time serta untuk pendekatan manajemen state yang dibangun berdasarkan streams.
Menangani async dengan benar — termasuk status loading/error/data yang dikelola FutureBuilder dan StreamBuilder — adalah fondasi untuk membangun aplikasi yang mengambil dan menampilkan data dengan benar (inti dari sebagian besar aplikasi).
Karena aplikasi Flutter terus-menerus melakukan operasi asynchronous (jaringan, file, data real-time) dan menampilkan hasilnya memerlukan penanganan status async dengan benar, dan karena Futures, Streams, async/await, dan widget Builder adalah alat penting untuk ini, memahami async, Futures, dan Streams di Flutter adalah pengetahuan penting yang sering diterapkan — keterampilan fundamental untuk membangun aplikasi yang menangani data dan operasi async dengan benar, keterampilan inti yang diperlukan di hampir setiap aplikasi Flutter nyata yang mengambil atau memproses data.