A Flutter alkalmazások állandóan aszinkron operációkat kezelnek (hálózati kérések, fájl hozzáférés, adatbázis lekérdezések). A Dart Futures (egyetlen aszinkron eredmény) és Streams (aszinkron események sorozata), az async/await és olyan widgetek, mint a FutureBuilder/StreamBuilder, elengedhetetlenek az aszinkron felhasználói felülethez.
// 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
A Future = egy érték, amely később érhető el (egy hálózati válasz, egy fájl olvasása). Az async/await az aszinkron kódot szekvenciálisan olvashatóvá teszi.
// 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}'))
Az async, a Futures és a Streams megértése elengedhetetlen, mivel a Flutter alkalmazások állandóan aszinkron operációkkal foglalkoznak, ezért azok helyes kezelése alapvető a valós alkalmazások felépítéséhez.
Szinte minden alkalmazás végez aszinkron munkát — hálózati kéréseket, fájl hozzáférést, adatbázis lekérdezéseket, valós idejű adatokat — és a Dart aszinkron primitívei az ezek kezelésének módja.
A Futures megértése (amely egy aszinkron eredményt reprezentál, amely később érhető el, például egy hálózati válasz) az async/await-tel (amely az aszinkron kódot szekvenciálisan és tisztán olvashatóvá teszi) elengedhetetlen az aszinkron operációk végrehajtásához.
A FutureBuilder megértése különösen fontos a felhasználói felülethez: a Future állapota alapján felépíti a felhasználói felületet, megfelelően kezelve a betöltési, hiba- és adatállapotokat — amely pontosan azt jelenti, hogy valós alkalmazásoknak szüksége van (spinner megjelenítése betöltés közben, hibaüzenet megjelenítése hiba esetén, és az adat sikeres megjelenítése), egy gyakori és elengedhetetlen minta az aszinkron felhasználói felülethez.
A Streams megértése (aszinkron események sorozata az idő múlásával, például élő adatok, websockets vagy szenzor-adatok) és StreamBuilder (a felhasználói felület újraépítése új események érkezésekor) elengedhetetlen a reaktív, valós idejű felhasználói felületekhez és a streamen alapuló állapotkezelési megközelítésekhez.
Az aszinkron kezelés helyes végrehajtása — beleértve a betöltési/hiba/adat állapotokat, amelyeket a FutureBuilder és StreamBuilder kezelnek — alapvető az olyan alkalmazások felépítéséhez, amelyek megfelelően lekérdezik és megjelenítik az adatokat (a legtöbb alkalmazás magja).
Mivel a Flutter alkalmazások állandóan végeznek aszinkron operációkat (hálózat, fájlok, valós idejű adatok), és azok eredményeinek megjelenítéséhez az aszinkron állapotok helyes kezelésére van szükség, és mivel a Futures, Streams, async/await és a Builder widgetek az ehhez szükséges alapvető eszközök, az async, a Futures és a Streams megértése a Flutter-ben elengedhetetlen, gyakran alkalmazott tudás — alapvető készség, amely szinte minden valós Flutter alkalmazásban szükséges, amely adatokat lekérdez vagy feldolgoz.