Las aplicaciones Flutter manejan constantemente operaciones asincrónicas (solicitudes de red, acceso a archivos, consultas a bases de datos). Los Futures de Dart (resultados async individuales) y Streams (secuencias de eventos async), junto con async/await y widgets como FutureBuilder/StreamBuilder, son esenciales para UI asincrónica.
// 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 valor único disponible más tarde (una respuesta de red, una lectura de archivo). async/await hace que el código async se lea secuencialmente.
// 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}'))
Entender async, Futures y Streams es esencial porque las aplicaciones Flutter constantemente tratan con operaciones asincrónicas, por lo que manejarlas correctamente es fundamental para construir aplicaciones reales.
Casi todas las aplicaciones realizan trabajo async — solicitudes de red, acceso a archivos, consultas a bases de datos, datos en tiempo real — y los primitivos async de Dart son cómo los manejas.
Entender Futures (representando un resultado async único disponible más tarde, como una respuesta de red) con async/await (haciendo que el código async se lea secuencialmente y limpiamente) es esencial para realizar operaciones async.
Entender FutureBuilder es particularmente importante para UI: construye UI basada en el estado de un Future, manejando correctamente estados de carga, error y datos — que es exactamente lo que las aplicaciones reales necesitan (mostrar un spinner mientras carga, un mensaje de error al fallar, y los datos al éxito), un patrón común y esencial para UI async.
Entender Streams (secuencias de eventos async en el tiempo, como datos en vivo, websockets o lecturas de sensores) y StreamBuilder (reconstruyendo la UI conforme llegan nuevos eventos) es esencial para UIs reactivas en tiempo real y para enfoques de gestión de estado basados en streams.
Manejar async correctamente — incluyendo los estados de carga/error/datos que FutureBuilder y StreamBuilder manejan — es fundamental para construir aplicaciones que obtengan y muestren datos correctamente (el núcleo de la mayoría de aplicaciones).
Puesto que las aplicaciones Flutter constantemente realizan operaciones asincrónicas (red, archivos, datos en tiempo real) y mostrar sus resultados requiere manejar estados async correctamente, y puesto que Futures, Streams, async/await y los widgets Builder son las herramientas esenciales para esto, entender async, Futures y Streams en Flutter es conocimiento esencial, aplicado frecuentemente — fundamental para construir aplicaciones que manejen datos y operaciones async correctamente, una habilidad central necesaria en prácticamente todas las aplicaciones Flutter reales que obtienen o procesan datos.