Flutter programos nuolat tvarkosi su asinchroninėmis operacijomis (tinklo užklausomis, failų pasiklysdinimu, duomenų bazės užklausomis). Dart Futures (vienas asinchroninis rezultatas) ir Streams (asinchroninių įvykių sekos), kartu su async/await ir valdikliais tokiais kaip FutureBuilder/StreamBuilder, yra neatsiejami asinchroninio vartotojo sąsajos elementai.
// 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 = viena reikšmė, pasiekiama vėliau (tinklo atsakas, failo skaitymas). async/await daro asinchroninį kodą skaitomą nuosekliai.
// 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}'))
Supratimas apie async, Futures ir Streams yra neatsiejamas, nes Flutter programos nuolat tvarkosi su asinchroninėmis operacijomis, todėl jų tinkama tvarkyba yra fundamentali tikrų programų kūrimo pagrindas.
Fast beveik kiekviena programa atlieka asinchroninį darbą — tinklo užklausas, failų pasiklydimą, duomenų bazės užklausas, realaus laiko duomenis — ir Dart asinchroniniai primityvai yra tai, kaip tai tvarkyti.
Supratimas apie Futures (atstovaujančius vieną asinchroninį rezultatą, pasiekiamą vėliau, kaip tinklo atsakas) kartu su async/await (daryti asinchroninį kodą skaitomą nuosekliai ir švariai) yra neatsiejamas asinchroninėms operacijoms atlikti.
Supratimas apie FutureBuilder yra ypač svarbus vartotojo sąsajai: jis kuria vartotojo sąsają pagal Future būseną, tinkamai tvarkydamas įkėlimo, klaidos ir duomenų būsenas — o tai yra tiksliai tai, ką reali programos reikalauja (rodyti sukimąsi įkėlimo metu, klaidos pranešimą žlugus ir duomenis sėkmės atveju), dažna ir neatsiejama asinchroninio vartotojo sąsajos šablonas.
Supratimas apie Streams (asinchroninių įvykių sekos per laiką, tokios kaip gyvi duomenys, websockets arba jutiklių skaitymai) ir StreamBuilder (vartotojo sąsajos atnaujinimas kai kas tik atvyksta nauji įvykiai) yra neatsiejamas reaktyviam, realaus laiko vartotojo sąsajoms ir valstybės vadybos požiūriams, pagrįstiems srautais.
Tinkama asinchroninių operacijų tvarkyba — įskaitant įkėlimo/klaidos/duomenų būsenas, kurias tvarksto FutureBuilder ir StreamBuilder — yra fundamentali programų, kurios gauna ir rodo duomenis, kūrimui (tai yra daugiau nei dauguma programų).
Kadangi Flutter programos nuolat atlieka asinchronines operacijas (tinklą, failus, realaus laiko duomenis) ir jų rezultatų rodymas reikalauja tinkrai tvarkyti asinchronines būsenas, ir kadangi Futures, Streams, async/await ir Builder valdikliai yra pagrindiniai įrankiai tam, supratimas apie async, Futures ir Streams programoje Flutter yra neatsiejamas, dažnai taikomas žinojimas — fundamentalus įgūdis reikalingas praktiškai kiekvieno tikro Flutter taikymo, kuris gauna arba apdoroja duomenis, sukūrimui.