web-dev-qa-db-fra.com

RxJS: Observable.create () vs. Observable.from ()

Quelle est la différence entre ces deux?

return Observable.create(function(observer) {
    if (array)
        observer.next([]);
    else
        observer.next(null);
    observer.complete();
});

et 

return Observable.from( array ? [] : null );

Je pensais que cela pourrait être la même chose, mais cela ne fonctionnait pas.

javascriptrxjsobservablerxjs5
7
Ondra Žižka

La create(...) est une méthode générique de fabrique Observable pour créer un Observable dans lequel vous dicterez explicitement comment les valeurs sont passées à la Subscriber.

Par exemple, si vous créez une base de temporisation Observable (n’existe-t-elle pas déjà sous le nom Observable.timer)?

   Observable.create(observer => {
     const timeoutId = setTimeout(() => {
       observer.next(0);
       observer.complete();
     }, 500);

     return () => clearTimeout(timeoutId);
   });

La from(...) est ce que j'appelle un opérateur conformance dans la mesure où il tente de contraindre un type de données passé dans un Observable (le rendre conforme). Cela signifie qu’il acceptera une variété de types et les convertira en Observables. Ces types incluent:

  • Tableaux
  • Promesses
  • Générateurs
  • Choses observables

Il existe également des convertisseurs spécifiques que vous pouvez trouver, tels que fromArray et fromPromise, qui convertissent spécifiquement ces types, mais from plutôt un couteau suisse de ces méthodes.

Si vous n'avez besoin que d'une seule valeur, vous devriez utiliser Observable.of (les documents semblent périmés, just/return a été renommé of dans RxJS 5 et je ne pense plus qu'ils soient aliasés).

c'est à dire.

// Don't quote me on the import part
import 'rxjs/add/observable/of';

Observable.of(1, 2, 3, 4).subscribe();
15
paulpdaniels

Lorsque vous retournez un tableau, une différence est que "create/next" émettra le tableau entier en une fois mais que "from" émettra chaque élément autant de fois que sa longueur, ainsi à l'abonné,

Observable.create(observer => observer.next(myArray)) se déclenchera une fois pour renvoyer myArray alors que Observable.from(myArray) émettra de nombreux événements onNext pour renvoyer un élément à chaque fois. 

0
bob

Une différence est la suivante: Observable.from() interdit spécifiquement null comme quelque chose qu’il accepte. La première solution est donc une sorte de solution de contournement pour créer un retour observable null. (Voir la réponse acceptée pour la différence principale cependant.)

Une meilleure façon (plus courte) serait d’utiliser juste :

return Observable.just( array ? [] : null );

Mais je ne trouvais pas où l'obtenir ni comment l'importer.

import 'rxjs/add/operator/just';

Ce n'est pas présent dans ma distribution de rxjs.
Edit:just a été renommé en of, voir la réponse acceptée.

0
Ondra Žižka

Observable.from ():
Vous avez une liste de valeurs (qui n’a aucun rapport avec Rx) et un observable est créé de cette liste Lorsqu'un observateur s'abonne à cet observable, la liste de valeurs est transmise un par un en tant qu'événements Next (), puis Completed () est finalement transmise et vous ne pouvez pas contrôler ce processus.

(Observable.create ():} _
Vous créez un observable en transmettant une liste d’événements (et non de valeurs) à vos observateurs. Vous avez le contrôle de l'ordre des événements. Si vous n'avez pas appelé onCompleted, il ne sera pas appelé automatiquement. Vous pouvez appeler onError exprès entre deux événements (à des fins de test).

0
Tony