web-dev-qa-db-fra.com

Comment exécuter une fonction récurrente dans Dart?

Je voudrais exécuter une fonction encore et encore, avec un délai entre les deux. Comment puis-je faire cela avec Dart?

dart
42
Seth Ladd

Vous pouvez utiliser la classe Timer pour planifier des fonctions ponctuelles et répétitives.

Répétition

Voici comment exécuter une fonction répétitive:

import 'Dart:async';
main() {
  const oneSec = const Duration(seconds:1);
  new Timer.periodic(oneSec, (Timer t) => print('hi!'));
}

Le Timer prend deux arguments, une durée et une fonction à exécuter. La durée doit être une instance de Duration. Le rappel doit prendre un seul paramètre, le temporisateur lui-même.

Annulation d'une minuterie répétée

Utilisez timer.cancel() pour annuler une minuterie répétée. C'est l'une des raisons pour lesquelles le temporisateur est passé à l'exécution de rappel à partir d'un temporisateur répétitif.

One-shot après un retard

Pour planifier une fonction ponctuelle après un délai (exécuter une fois, dans le futur):

import 'Dart:async';
main() {
  const twentyMillis = const Duration(milliseconds:20);
  new Timer(twentyMillis, () => print('hi!'));
}

Notez que le rappel pour un temporisateur à un coup ne prend pas de paramètre.

One-shot dès que possible

Vous pouvez également demander qu'une fonction soit exécutée dès que possible, au moins une boucle d'événement à l'avenir.

import 'Dart:async';
main() {
  Timer.run(() => print('hi!'));
}

En HTML

Les minuteries fonctionnent même en HTML. En fait, window.setTimeout A été supprimé, donc Timer est le seul moyen d'exécuter une fonction à l'avenir.

88
Seth Ladd

https://api.dartlang.org/stable/1.24.3/Dart-async/Stream/Stream.periodic.html

import 'Dart:async';

StreamSubscription periodicSub;

void main() {
  periodicSub = new Stream.periodic(const Duration(milliseconds: 500), (v) => v)
      .take(10)
      .listen((count) => print('tick $count'));
}

ou si le compteur n'est pas requis juste

import 'Dart:async';

StreamSubscription periodicSub;

void main() {
  periodicSub = new Stream.periodic(const Duration(milliseconds: 500))
      .take(10)
      .listen((_) => print('tick'));
}
10
Günter Zöchbauer

Vous pouvez également utiliser Future.delayed et attendre pour retarder l'exécution:

Future<Null> delay(int milliseconds) {
  return new Future.delayed(new Duration(milliseconds: milliseconds));
}


main() async {
  await delay(500);
  print('Delayed 500 milliseconds');
}
6
Matt S.

alternative;

Timer interval(Duration duration, func) {
  Timer function() {
    Timer timer = new Timer(duration, function);

    func(timer);

    return timer;
  }

  return new Timer(duration, function);
}

int i = 0;

interval(new Duration(seconds: 1), (timer) {
  print(i++);

  if (i > 5) timer.cancel();
});
5
Ahmet Şimşek

Exemple de minuterie de 5 secondes

bool isStopped = false; //global

sec5Timer() {
  Timer.periodic(Duration(seconds: 5), (timer) {
    if (isStopped) {
      timer.cancel();
    }
    print("Dekhi 5 sec por por kisu hy ni :/");
  });
}

Appel depuis n'importe quelle fonction

sec5Timer();

Arrêtez de n'importe quelle fonction

isStopped = true;

Pour vous débarrasser, vous pouvez utiliser ce code ou cette technique.

 @override
  void initState() {
    _timer = new Timer.periodic(widget.refreshRate, 
      (Timer timer) => _updateDisplayTime(inheritedWidget));
    super.initState();
  }

  @override
  void dispose() {
    _timer.cancel();
    super.dispose();
  }
1
Rafsan Uddin Beg Rizan