Programu za Flutter zinashughulikia kila wakati shughuli za asynchronous (maombi ya network, ufikiaji wa faili, queries za database). Futures za Dart (matokeo moja ya async) na Streams (mlolongo wa matukio ya async), pamoja na async/await na widgets kama FutureBuilder/StreamBuilder, ni muhimu kwa async 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 = thamani moja inayopatikana baadaye (response ya network, kusoma faili). async/await inafanya code ya async isomeke kwa mfululizo.
// 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}'))
Kuelewa async, Futures, na Streams ni muhimu kwa sababu programu za Flutter zinashughulika kila wakati na shughuli za asynchronous, kwa hivyo kuzishughulikia kwa usahihi ni jambo la msingi kwa kujenga programu halisi.
Karibu kila programu inafanya kazi ya async — maombi ya network, ufikiaji wa faili, queries za database, data ya wakati halisi — na primitives za async za Dart ndizo unavyozishughulikia.
Kuelewa Futures (zinazowakilisha matokeo moja ya async yanayopatikana baadaye, kama response ya network) na async/await (ikifanya code ya async isomeke kwa mfululizo na kwa usafi) ni muhimu kwa kufanya shughuli za async.
Kuelewa FutureBuilder ni muhimu hasa kwa UI: inajenga UI kulingana na state ya Future, ikishughulikia ipasavyo loading, error, na data states — ambayo ndiyo hasa programu halisi zinahitaji (kuonyesha spinner wakati wa kupakia, ujumbe wa kosa wakati wa kushindwa, na data wakati wa mafanikio), mpangilio wa kawaida na muhimu kwa async UI.
Kuelewa Streams (mlolongo wa matukio ya async kwa muda, kama data ya moja kwa moja, websockets, au usomaji wa sensor) na StreamBuilder (ikijenga upya UI matukio mapya yanapowasili) ni muhimu kwa UI za reactive, za wakati halisi na kwa njia za usimamizi wa state zilizojengwa juu ya streams.
Kushughulikia async kwa usahihi — ikiwemo loading/error/data states ambazo FutureBuilder na StreamBuilder zinasimamia — ni jambo la msingi kwa kujenga programu zinazoleta na kuonyesha data ipasavyo (kiini cha programu nyingi).
Kwa kuwa programu za Flutter zinafanya kila wakati shughuli za asynchronous (network, faili, data ya wakati halisi) na kuonyesha matokeo yake kunahitaji kushughulikia async states kwa usahihi, na kwa kuwa Futures, Streams, async/await, na widgets za Builder ndizo zana muhimu kwa hili, kuelewa async, Futures, na Streams katika Flutter ni maarifa muhimu yanayotumika mara kwa mara — ya msingi kwa kujenga programu zinazoshughulikia data na shughuli za async kwa usahihi, ujuzi wa msingi unaohitajika katika karibu kila programu halisi ya Flutter inayoleta au kuchakata data.