Les apps Flutter gèrent constamment des opérations asynchrones (requêtes réseau, accès aux fichiers, requêtes de base de données). Les Futures de Dart (résultats async uniques) et Streams (séquences d'événements async), avec async/await et des widgets comme FutureBuilder/StreamBuilder, sont essentiels pour l'UI asynchrone.
// 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 = une valeur unique disponible plus tard (une réponse réseau, une lecture de fichier). async/await rend le code async lisible de manière séquentielle.
// 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}'))
Comprendre async, Futures et Streams est essentiel car les apps Flutter gèrent constamment des opérations asynchrones, donc les gérer correctement est fondamental pour construire des apps réelles.
Presque chaque app effectue du travail async — requêtes réseau, accès aux fichiers, requêtes de base de données, données en temps réel — et les primitives async de Dart sont la façon dont vous les gérez.
Comprendre les Futures (représentant un résultat async unique disponible plus tard, comme une réponse réseau) avec async/await (rendant le code async lisible de manière séquentielle et claire) est essentiel pour effectuer des opérations async.
Comprendre FutureBuilder est particulièrement important pour l'UI : elle construit l'UI en fonction de l'état d'une Future, en gérant correctement les états de chargement, erreur et données — c'est exactement ce dont les apps réelles ont besoin (afficher un spinner pendant le chargement, un message d'erreur en cas d'échec, et les données en cas de succès), un pattern courant et essentiel pour l'UI async.
Comprendre les Streams (séquences d'événements async dans le temps, comme des données en direct, des websockets ou des lectures de capteurs) et StreamBuilder (reconstruire l'UI à l'arrivée de nouveaux événements) est essentiel pour les UIs réactives en temps réel et pour les approches de gestion d'état construites sur les streams.
Gérer async correctement — incluant les états de chargement/erreur/données que FutureBuilder et StreamBuilder gèrent — est fondamental pour construire des apps qui récupèrent et affichent les données correctement (le cœur de la plupart des apps).
Puisque les apps Flutter effectuent constamment des opérations asynchrones (réseau, fichiers, données en temps réel) et afficher leurs résultats nécessite de gérer correctement les états async, et puisque Futures, Streams, async/await et les widgets Builder sont les outils essentiels pour cela, comprendre async, Futures et Streams dans Flutter est une connaissance essentielle et fréquemment appliquée — fondamentale pour construire des apps qui gèrent correctement les données et les opérations async, une compétence centrale nécessaire dans pratiquement chaque application Flutter réelle qui récupère ou traite des données.