En Flutter, los conceptos de Future y Stream son esenciales para la programación asíncrona, permitiendo a los desarrolladores manejar operaciones que no se completan de inmediato, como consultas a APIs o interacciones con bases de datos.
FUTURE: Un Future representa una operación asíncrona que terminará en un momento específico con un único valor o un error. Es como una promesa de que algún dato estará disponible en el futuro. Por ejemplo, si estás esperando una respuesta de una API, utilizarías un Future para manejar la respuesta cuando llegue.
import 'dart:async';
import 'package:flutter/material.dart';
void main() {
runApp(MyApp());
}
class MyApp extends StatelessWidget {
@override
Widget build(BuildContext context) {
return MaterialApp(
home: FutureExample(),
);
}
}
class FutureExample extends StatefulWidget {
@override
_FutureExampleState createState() => _FutureExampleState();
}
class _FutureExampleState extends State<FutureExample> {
// Ejemplo de Future que simula una tarea asíncrona
Future<String> fetchData() async {
await Future.delayed(Duration(seconds: 2)); // Simulación de carga de datos
return 'Datos cargados exitosamente';
}
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(
title: Text('Ejemplo de Future'),
),
body: Center(
child: FutureBuilder(
future: fetchData(),
builder: (context, AsyncSnapshot<String> snapshot) {
if (snapshot.connectionState == ConnectionState.waiting) {
return CircularProgressIndicator();
} else if (snapshot.hasError) {
return Text('Error al cargar datos: ${snapshot.error}');
} else {
return Text(snapshot.data ?? '');
}
},
),
),
);
}
}
Stream: Un Stream, por otro lado, es adecuado para manejar múltiples eventos que ocurren a lo largo del tiempo. En lugar de esperar un solo valor, un Stream puede emitir varios valores en diferentes momentos. Esto es útil para situaciones donde necesitas reaccionar a una serie de eventos continuos, como actualizaciones de datos en tiempo real.
import 'dart:async';
import 'package:flutter/material.dart';
void main() {
runApp(MyApp());
}
class MyApp extends StatelessWidget {
@override
Widget build(BuildContext context) {
return MaterialApp(
home: StreamExample(),
);
}
}
class StreamExample extends StatefulWidget {
@override
_StreamExampleState createState() => _StreamExampleState();
}
class _StreamExampleState extends State<StreamExample> {
// Simulación de un Stream que carga datos asíncronamente
Stream<String> loadData() async* {
await Future.delayed(Duration(seconds: 1));
yield 'Cargando datos...';
await Future.delayed(Duration(seconds: 2));
yield 'Datos cargados exitosamente';
}
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(
title: Text('Ejemplo de Stream - Cargando Data'),
),
body: Center(
child: StreamBuilder<String>(
stream: loadData(),
builder: (context, snapshot) {
if (snapshot.connectionState == ConnectionState.waiting) {
return CircularProgressIndicator();
} else if (snapshot.hasError) {
return Text('Error: ${snapshot.error}');
} else if (snapshot.hasData) {
return Text(snapshot.data ?? '');
} else {
return Text('Stream completado');
}
},
),
),
);
}
}
Similitudes:
- Ambos se usan para gestionar operaciones asíncronas en Dart, el lenguaje de programación de Flutter.
- Facilitan la escritura de código que depende de la disponibilidad futura de datos o eventos.
Diferencias:
- Future se utiliza cuando esperas un solo resultado eventual.
- Stream se emplea cuando necesitas manejar una secuencia de resultados o eventos continuos.
Si te resultó útil esta descripción, no dudes en compartirla y dejar tus comentarios. 🚀
Mira mi sitio: www.albertoguaman.com
