Rxjs: Observable.combineLatest vs Observable.forkJoin

Question

Demandez-vous quelles sont les différences entre Observable.combineLatest et Observable.forkJoin ? Autant que je sache, la seule différence est que forkJoin s'attend à ce que les observables soient terminés, tandis que combineLatest renvoient les dernières valeurs.

Answer 1

Non seulement est - forkJoin nécessitent la saisie de tous les phénomènes observables à être achevé, mais il renvoie également observable qui produit une valeur unique qui est un tableau de la dernière valeurs produites par l'entrée observables. En d'autres termes, il attend jusqu'à la dernière entrée observables se termine, puis produit une valeur unique et complète.

En revanche, combineLatest renvoie une Observable qui produit une nouvelle valeur à chaque fois que l'entrée observables faire, une fois que toutes les entrées observables ont produit au moins une valeur. Cela signifie qu'il pourrait avoir des valeurs infinies et peut ne pas se terminer. Cela signifie également que les données d'entrée observables n'avez pas à remplir avant la production en valeur.

Answer 2

forkJoin - Lorsque tous les observables sont terminés, émettez la dernière valeur émise de chacun.

combineLatest - Lorsqu'un observable émet une valeur, émet la dernière valeur de chaque.

L'utilisation est assez similaire, mais vous ne devez pas oublier de vous désabonner de combineLatest contrairement à forkJoin .

Answer 3

Aussi:

combineLatest(...) s'exécute observables dans l'ordre, un par un

combineLatest utilise en interne concat, ce qui signifie une valeur doit être obtenu pour chaque observable dans le tableau avant de passer au suivant.

// partial source of static combineLatest (uses the rxjs/operators combineLatest internally):
// If you're using typescript then the output array will be strongly typed based on type inference
return function (source) { return source.lift.call(from_1.from([source].concat(observables)), 
                           new combineLatest_1.CombineLatestOperator(project)); };

forkJoin(...) s'exécute observables en parallèle, dans le même temps

Si vous avez 3 source des observables, et ils ont chacun de prendre 5 secondes pour s'exécuter, puis il va prendre 15 secondes pour combineLatest à exécuter. Alors qu' forkJoin de leur exécution en parallèle de sorte qu'il prendra 5 secondes.

Donc, forkJoin travaille plutôt à la manière d' Promise.all(...) où la commande n'est pas exécutée.

Examen de la gestion des erreurs:

Si l'un des observables erreur - combineLatest les suivants ne seront pas exécutés, mais avec forkJoin ils sont tous en cours d'exécution. Donc, combineLatest peut être utile d'exécuter une "séquence" des observables et de recueillir le résultat tous ensemble.

---

Avancé remarque: Si la source observables sont déjà "running" (souscrit par quelque chose d'autre) et que vous utilisez share - alors vous ne verrez pas ce comportement.

Encore plus avancé remarque: CombineLatest vous donnera toujours la dernière à partir de chaque source, de sorte que si l'une des source observables émet plusieurs valeurs, vous obtiendrez la dernière. Il ne s'agit pas d'obtenir une valeur unique pour chaque source et passer à la suivante. Si vous devez vous assurer que vous obtenez seulement la "disponibilité" pour chaque source observables vous pouvez ajouter .pipe(take(1)) à la source observables comme vous l'ajouter au tableau d'entrée.