Notions de base des Streams

Fait partie de la section Programmation Orientée Objet du Journey Dart de Coddy. Leçon 77 sur 110.

Alors qu'un Future fournit une valeur unique, un Stream fournit une séquence de valeurs au fil du temps. Considérez-le comme un tuyau qui peut émettre plusieurs éléments de données - parfait pour les événements, les mises à jour en temps réel ou le traitement des données morceau par morceau.

Vous pouvez créer un flux simple en utilisant Stream.fromIterable() ou une fonction génératrice asynchrone avec async* et yield :

Stream<int> countToThree() async* {
  yield 1;
  yield 2;
  yield 3;
}

Future<void> main() async {
  await for (var number in countToThree()) {
    print(number);
  }
}
// Résultat : 1, 2, 3

Le mot-clé async* indique une fonction qui renvoie un Stream, et yield émet chaque valeur. Pour consommer le flux, utilisez await for, qui traite chaque valeur au fur et à mesure de son arrivée.

Vous pouvez également écouter un flux en utilisant la méthode listen(), qui prend une fonction de rappel :

Stream<String> greetings() async* {
  yield 'Hello';
  yield 'Hi';
  yield 'Hey';
}

void main() {
  greetings().listen((message) {
    print(message);
  });
}

La différence clé avec les Futures : un Future se termine une seule fois avec une valeur unique, tandis qu’un Stream peut émettre de nombreuses valeurs avant d’être terminé. Cela rend les Streams idéaux pour gérer des données continues comme les interactions utilisateur, les relevés de capteurs ou les données arrivant par blocs.

Défi

Facile

Construisons un système de compte à rebours qui émet des valeurs au fil du temps à l’aide de flux ! Vous allez créer une classe qui génère une séquence de nombres pour le compte à rebours, afin de montrer comment les flux transmettent plusieurs valeurs plutôt qu’une seule.

Vous allez organiser votre code en deux fichiers :

countdown.dart : créez une classe Countdown qui génère des flux de compte à rebours. Votre classe doit comporter :
- Un champ start (int) qui stocke le nombre de départ du compte à rebours
- Un constructeur qui prend le nombre de départ
- Une méthode countDown() qui renvoie un Stream<int>. Utilisez async* et yield pour émettre les nombres de start jusqu’à 0 inclus
- Une méthode countDownWithMessage() qui renvoie un Stream<String>. Elle doit émettre des chaînes au format 'T-minus [number]' pour chaque nombre de start jusqu’à 1, puis émettre 'Liftoff!' comme valeur finale
main.dart : importez votre fichier de compte à rebours et présentez les deux méthodes de flux. Votre fonction main doit être asynchrone et :
- Créer une instance de Countdown en commençant à 3
- Afficher Number countdown:
- Utiliser await for pour parcourir countDown() et afficher chaque nombre
- Afficher une ligne vide
- Afficher Launch sequence:
- Utiliser await for pour parcourir countDownWithMessage() et afficher chaque message

Remarquez comment chaque instruction yield émet une valeur via le flux, tandis que await for traite chaque valeur au fur et à mesure de son arrivée. Contrairement à un Future qui fournit un seul résultat, vos flux émettront plusieurs valeurs successivement !

Sortie attendue :

Number countdown:
3
2
1
0

Launch sequence:
T-minus 3
T-minus 2
T-minus 1
Liftoff!

Essayez vous-même

import 'countdown.dart';

Future<void> main() async {
  // TODO: Créer une instance de Countdown commençant à 3
  
  // TODO: Afficher 'Number countdown:'
  
  // TODO: Utiliser await for pour itérer à travers countDown() et afficher chaque nombre
  
  // TODO: Afficher une ligne vide
  
  // TODO: Afficher 'Launch sequence:'
  
  // TODO: Utiliser await for pour itérer à travers countDownWithMessage() et afficher chaque message
}