Flutter aplikacije stalno obavljaju asinkrona operacije (mrežni zahtjevi, pristup datotekama, upiti baze podataka). Dart-ovi Futures (jedan asinkron rezultat) i Streams (sekvence asinkronih događaja), s async/await i widgetima poput FutureBuilder/StreamBuilder, su neophodni za asinkroni UI.
// 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 = pojedinačna vrijednost dostupna kasnije (mrežni odgovor, čitanje datoteke). async/await čini asinkroni kod čitljivim uzastopno.
// 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}'))
Razumijevanje async, Futures i Streams je ključno jer Flutter aplikacije stalno radi s asinkronim operacijama, pa je njihovo ispravno rukovanje fundamentalno za izgradnju stvarnih aplikacija.
Skoro svaka aplikacija izvršava asinkroni rad — mrežne zahtjeve, pristup datotekama, upite baze podataka, podatke u realnom vremenu — i Dart-ovi asinkroni primitivi su način na koji to rukovaćete.
Razumijevanje Futures-a (koji predstavljaju jedan asinkron rezultat dostupan kasnije, kao što je mrežni odgovor) s async/await (što čini asinkroni kod čitljivim uzastopno i čisto) je bitno za izvršavanje asinkronih operacija.
Razumijevanje FutureBuilder-a je posebno važno za UI: gradi UI na temelju stanja Future-a, pravilno rukovajući stanjem učitavanja, greške i podataka — što je upravo ono što prave aplikacije trebaju (prikazivanje spinner-a tijekom učitavanja, poruku o grešci pri neuspjehu, te podatke pri uspjehu), čest i neophodno važan uzorak za asinkroni UI.
Razumijevanje Streams-a (sekvence asinkronih događaja tijekom vremena, kao što su direktni podaci, websockets ili senzorska očitanja) i StreamBuilder-a (ponovno gradnja UI-a kako novi događaji dolaze) je ključno za reaktivne, UI-e u realnom vremenu i za pristupe upravljanju stanjem izgrađene na tokovima.
Ispravno rukovanje asinkronim kodom — uključujući stanja učitavanja/greške/podataka koja FutureBuilder i StreamBuilder upravljaju — je fundamentalno za izgradnju aplikacija koje pravilno dohvaćaju i prikazuju podatke (jezgra većine aplikacija).
Budući da Flutter aplikacije stalno izvršavaju asinkrone operacije (mreža, datoteke, podaci u realnom vremenu) i prikazivanje njihovih rezultata zahtjeva ispravno rukovanje asinkronim stanjima, i budući da su Futures, Streams, async/await i Builder widgeti bitni alati za ovo, razumijevanje async, Futures i Streams u Flutteru je bitno, često primijenjeno znanje — fundamentalno za izgradnju aplikacija koje pravilno rukovaju podacima i asinkronim operacijama, osnovnu vještinu potrebnu u gotovo svakoj stvarnoj Flutter aplikaciji koja dohvaća ili obrađuje podatke.