Aplicativos Flutter constantemente lidam com operações assíncronas (requisições de rede, acesso a arquivos, consultas de banco de dados). Os Futures do Dart (resultados async únicos) e Streams (sequências de eventos async), com async/await e widgets como FutureBuilder/StreamBuilder, são essenciais para UI async.
// 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 = um valor único disponível depois (uma resposta de rede, uma leitura de arquivo). async/await torna o código async legível sequencialmente.
// 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 e Streams é essencial porque aplicativos Flutter constantemente lidam com operações assíncronas, então tratá-las corretamente é fundamental para construir aplicativos reais.
Quase todo aplicativo realiza trabalho async — requisições de rede, acesso a arquivos, consultas de banco de dados, dados em tempo real — e as primitivas async do Dart são como você as trata.
Entender Futures (representando um resultado async único disponível depois, como uma resposta de rede) com async/await (tornando o código async legível sequencialmente e limpo) é essencial para realizar operações async.
Entender FutureBuilder é particularmente importante para UI: ele constrói UI com base no estado de um Future, tratando corretamente os estados de carregamento, erro e dados — que é exatamente o que aplicativos reais precisam (mostrando um spinner enquanto carrega, uma mensagem de erro na falha e os dados no sucesso), um padrão comum e essencial para UI async.
Entender Streams (sequências de eventos async ao longo do tempo, como dados ao vivo, websockets ou leituras de sensores) e StreamBuilder (reconstruindo a UI conforme novos eventos chegam) é essencial para UIs reativas e em tempo real e para abordagens de gerenciamento de estado construídas em streams.
Tratar async corretamente — incluindo os estados de carregamento/erro/dados que FutureBuilder e StreamBuilder gerenciam — é fundamental para construir aplicativos que buscam e exibem dados corretamente (o núcleo da maioria dos aplicativos).
Como aplicativos Flutter constantemente realizam operações assíncronas (rede, arquivos, dados em tempo real) e exibir seus resultados requer tratar estados async corretamente, e como Futures, Streams, async/await e os widgets Builder são as ferramentas essenciais para isso, entender async, Futures e Streams no Flutter é conhecimento essencial e frequentemente aplicado — fundamental para construir aplicativos que tratam dados e operações async corretamente, uma habilidade central necessária em praticamente todo aplicativo Flutter real que busca ou processa dados.