Aplikacionet Flutter vazhdimisht trajtojnë operacione asinkrone (kërkesa rrjeti, qasje në skedarë, pyetje në bazën e të dhënave). Futures të Dart-it (rezultate të vetme asinkrone) dhe Streams (sekuenca të ngjarjeve asinkrone), me async/await dhe widget-e si FutureBuilder/StreamBuilder, janë thelbësorë për UI asinkroni.
// 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 = një vlerë e vetme e disponueshme më vonë (përgjigje rrjeti, lexim skedar). async/await bën kodin asinkron të lexohet në mënyrë sekuenciale.
// 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}'))
Përfaqësimi i async, Futures, dhe Streams është thelbësor sepse aplikacionet Flutter vazhdimisht merren me operacione asinkrone, kështu që trajtimi i tyre i saktë është themelor për ndërtimin e aplikacioneve të vërteta.
Praktikisht çdo aplikacion kryen punë asinkrone — kërkesa rrjeti, qasje në skedarë, pyetje në bazën e të dhënave, të dhëna në kohë reale — dhe primitivet asinkrone të Dart-it janë mënyra se si i trajtoni ato.
Përfaqësimi i Futures (që përfaqësojnë një rezultat të vetëm asinkron të disponueshëm më vonë, si përgjigje rrjeti) me async/await (duke bërë kodin asinkron të lexohet në mënyrë sekuenciale dhe të pastër) është thelbësor për kryerjen e operacioneve asinkrone.
Përfaqësimi i FutureBuilder është veçanërisht i rëndësishëm për UI: ai ndërton UI bazuar në gjendjen e një Future, duke trajtuar siç duhet gjendjet e ngarkimit, gabimit dhe të dhënave — e cila është pikërisht ajo që aplikacionet e vërteta kanë nevojë (shfaqja e një spineri gjatë ngarkimit, mesazh gabimi në dështim, dhe të dhënat në sukses), një model i zakonshëm dhe thelbësor për UI asinkroni.
Përfaqësimi i Streams (sekuenca të ngjarjeve asinkrone me kalimin e kohës, si të dhëna të drejtpërdrejtë, websocket-e, ose lexime sensorësh) dhe StreamBuilder (rikonstruktimi i UI ndërsa mbërrin ngjarje të reja) është thelbësor për UI-të reaktive, në kohë reale dhe për qasjet e menaxhimit të gjendjes të ndërtuara në streams.
Trajtimi i saktë i async — duke përfshirë gjendjet e ngarkimit/gabimit/të dhënave që FutureBuilder dhe StreamBuilder menaxhojnë — është themelor për ndërtimin e aplikacioneve që marrin dhe shfaqin të dhënat siç duhet (bërthamën e shumicës së aplikacioneve).
Meqënëse aplikacionet Flutter vazhdimisht kryejnë operacione asinkrone (rrjeti, skedarë, të dhëna në kohë reale) dhe shfaqja e rezultateve të tyre kërkon trajtimin e saktë të gjendjeve asinkrone, dhe meqë Futures, Streams, async/await, dhe widget-et Builder janë mjetet thelbësorë për këtë, përfaqësimi i async, Futures, dhe Streams në Flutter është njohuri thelbësorë, e aplikuar shpesh — themelor për ndërtimin e aplikacioneve që trajtojnë të dhënat dhe operacionet asinkrone siç duhet, një aftësi bërthamë e nevojshme në praktikisht çdo aplikacion të vërtetë Flutter që merr ose përpunon të dhëna.