Flutter-apps håndterer konstant asynkrone operationer (netværksanmodninger, filadgang, databaseforespørgsler). Darts Futures (enkelt async-resultater) og Streams (sekvenser af async-events), sammen med async/await og widgets som FutureBuilder/StreamBuilder, er essentielle for 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 = en enkelt værdi tilgængelig senere (et netværkssvar, en fillæsning). async/await gør asynkron kode læselig sekventielt.
// 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}'))
At forstå async, Futures og Streams er essentielt, fordi Flutter-apps konstant håndterer asynkrone operationer, så korrekt håndtering af dem er fundamental for at bygge rigtige apps.
Næsten hver app udfører async-arbejde — netværksanmodninger, filadgang, databaseforespørgsler, realtidsdata — og Darts async-primitiver er hvordan du håndterer det.
At forstå Futures (som repræsenterer et enkelt async-resultat tilgængeligt senere, som et netværkssvar) med async/await (som gør asynkron kode læselig sekventielt og rent) er essentielt for at udføre asynkrone operationer.
At forstå FutureBuilder er særlig vigtig for UI: den bygger UI baseret på en Futures tilstand, og håndterer korrekt loading-, error- og data-tilstande — hvilket er præcis hvad rigtige apps har brug for (viser en spinner under indlæsning, en fejlmeddelelse ved fejl, og dataene ved succes), et almindeligt og essentielt mønster for async UI.
At forstå Streams (sekvenser af async-events over tid, som live-data, websockets eller sensoraflæsninger) og StreamBuilder (genopbygning af UI når nye events ankommer) er essentielt for reaktiv, realtids-UI og for state management-tilgange bygget på streams.
Korrekt håndtering af async — inklusiv loading/error/data-tilstandene som FutureBuilder og StreamBuilder styrer — er fundamental for at bygge apps, der henter og viser data korrekt (kernen af de fleste apps).
Da Flutter-apps konstant udfører asynkrone operationer (netværk, filer, realtidsdata) og visning af deres resultater kræver korrekt håndtering af async-tilstande, og da Futures, Streams, async/await og Builder-widgets er de essentielle værktøjer til dette, er forståelse af async, Futures og Streams i Flutter essentiel, hyppigt anvendt viden — fundamental for at bygge apps, der håndterer data og asynkrone operationer korrekt, en kernekompetence, der er nødvendig i praktisk talt alle rigtige Flutter-applikationer, der henter eller behandler data.