Le app Flutter gestiscono costantemente operazioni asincrone (richieste di rete, accesso ai file, query di database). I Futures di Dart (singoli risultati asincroni) e gli Streams (sequenze di eventi asincroni), insieme a async/await e widget come FutureBuilder/StreamBuilder, sono essenziali per l'UI asincrona.
// 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 = un singolo valore disponibile in seguito (una risposta di rete, una lettura di file). async/await rende il codice asincrono leggibile sequenzialmente.
// 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}'))
Comprendere async, Futures e Streams è essenziale perché le app Flutter gestiscono costantemente operazioni asincrone, quindi gestirle correttamente è fondamentale per costruire app reali.
Quasi tutte le app eseguono lavoro asincrono — richieste di rete, accesso ai file, query di database, dati in tempo reale — e i primitivi asincroni di Dart sono il modo in cui li gestisci.
Comprendere i Futures (che rappresentano un singolo risultato asincrono disponibile in seguito, come una risposta di rete) insieme a async/await (che rendono il codice asincrono leggibile sequenzialmente e pulito) è essenziale per eseguire operazioni asincrone.
Comprendere FutureBuilder è particolarmente importante per l'UI: costruisce l'interfaccia basata sullo stato di un Future, gestendo correttamente gli stati di caricamento, errore e dati — che è esattamente quello che le app reali necessitano (mostrare uno spinner durante il caricamento, un messaggio di errore in caso di guasto e i dati al successo), un pattern comune ed essenziale per l'UI asincrona.
Comprendere gli Streams (sequenze di eventi asincroni nel tempo, come dati live, websocket o letture di sensori) e StreamBuilder (ricostruire l'UI al momento dell'arrivo di nuovi eventi) è essenziale per UI reattive e in tempo reale e per approcci di gestione dello stato costruiti su stream.
Gestire correttamente l'asincronia — inclusi gli stati di caricamento/errore/dati che FutureBuilder e StreamBuilder gestiscono — è fondamentale per costruire app che recuperano e visualizzano i dati correttamente (il nucleo della maggior parte delle app).
Poiché le app Flutter eseguono costantemente operazioni asincrone (rete, file, dati in tempo reale) e la visualizzazione dei loro risultati richiede di gestire correttamente gli stati asincroni, e poiché Futures, Streams, async/await e i widget Builder sono gli strumenti essenziali per questo, comprendere async, Futures e Streams in Flutter è una conoscenza essenziale e frequentemente applicata — fondamentale per costruire app che gestiscono i dati e le operazioni asincrone correttamente, una competenza essenziale necessaria praticamente in ogni app Flutter reale che recupera o elabora dati.