En la programación de flujos hay dos interfaces principales: Observable y Observer .

Observable es para el consumidor, se puede transformar y suscribir:

 observable.map(x => ...).filter(x => ...).subscribe(x => ...)

Observer es la interfaz que se utiliza para alimentar una fuente observable:

 observer.next(newItem)

Podemos crear un nuevo Observable con un Observer :

 var observable = Observable.create(observer => { observer.next('first'); observer.next('second'); ... }); observable.map(x => ...).filter(x => ...).subscribe(x => ...)

O bien, podemos usar un Sujeto que implemente las interfaces Observable y Observer :

 var source = new Subject(); source.map(x => ...).filter(x => ...).subscribe(x => ...) source.next('first') source.next('second')

Los Observables son de unidifusión por diseño y los Sujetos son de multidifusión por diseño.

si observa el siguiente ejemplo, cada suscripción recibe los diferentes valores como observables desarrollados como unidifusión por diseño.

 import {Observable} from 'rxjs'; let obs = Observable.create(observer=>{ observer.next(Math.random()); }) obs.subscribe(res=>{ console.log('subscription a :', res); //subscription a :0.2859800202682865 }); obs.subscribe(res=>{ console.log('subscription b :', res); //subscription b :0.694302021731573 });

esto podría ser extraño si espera los mismos valores en ambas suscripciones.

podemos superar este problema usando Sujetos. Subjects es similar a event-emitter y no se invoca para cada suscripción. considere el siguiente ejemplo.

 import {Subject} from 'rxjs'; let obs = new Subject(); obs.subscribe(res=>{ console.log('subscription a :', res); // subscription a : 0.91767565496093 }); obs.subscribe(res=>{ console.log('subscription b :', res);// subscription b : 0.91767565496093 }); obs.next(Math.random());

¡ambas suscripciones tienen el mismo valor de salida!.

observables

1. Son fríos: el código se ejecuta cuando tienen al menos un observador.

2. Crea una copia de los datos: Observable crea una copia de los datos para cada observador.

3. Unidireccional: el observador no puede asignar valor a observable (origen/maestro).

4. El código se ejecutará para cada observador. Si es una llamada HTTP, se llama para cada observador.

5. si es un servicio que queremos compartir entre todos los componentes, no tendrá el resultado más reciente, todos los suscriptores nuevos seguirán suscribiéndose al mismo observable y obtendrán valor desde cero

6. Los medios de unidifusión pueden emitir valores desde el observable, no desde cualquier otro componente.

Asunto

1. Están calientes: el código se ejecuta y el valor se transmite incluso si no hay un observador.

2. Comparte datos: los mismos datos se comparten entre todos los observadores.

3. bidireccional: el observador puede asignar valor a observable (origen/maestro).

4. Si está utilizando el sujeto, se perderá todos los valores que se transmiten antes de la creación del observador. Así que aquí viene el tema de reproducción

5. multidifusión, puede emitir valores a múltiples suscriptores y puede actuar como suscriptores y emisor