1 Ejecución directa / conversión
Utilícelo from
para convertir directamente una promesa creada previamente en una observable.
import { from } from 'rxjs';
// getPromise() will only be called once
const observable$ = from(getPromise());
observable$
será un observable atractivo que reproduce efectivamente el valor de las promesas para los suscriptores.
El cuerpo de promesas se está ejecutando o ya se ha resuelto cuando se crea el observable. Si la promesa interna se ha resuelto, un nuevo suscriptor al observable obtendrá su valor de inmediato.
2 Ejecución diferida en cada suscripción
Úselo defer
con una función de fábrica de promesas como entrada para diferir la creación y conversión de una promesa a una observable.
import { defer } from 'rxjs';
// getPromise() will be called every time someone subscribes to the observable$
const observable$ = defer(() => getPromise());
observable$
Será un frío observable .
La diferencia from
es que defer
espera a un suscriptor y solo entonces crea una nueva promesa llamando a la función de fábrica de promesa dada. Esto es útil cuando desea crear un observable pero no desea que la promesa interna se ejecute de inmediato. La promesa interna solo se ejecutará cuando alguien se suscriba a lo observable. Cada suscriptor también obtendrá su propio nuevo observable.
3 Muchos operadores aceptan promesas directamente
La mayoría de los operadores RxJS que combinan (por ejemplo merge
, concat
, forkJoin
, combineLatest
...) o transformar observables (por ejemplo switchMap
, mergeMap
, concatMap
, catchError
...) aceptar promesas directamente. Si está utilizando uno de ellos de todos modos, no tiene que usarlo from
para envolver una promesa primero (pero para crear un observable en frío aún podría tener que usarlo defer
).
// Execute two promises simultaneously
forkJoin(getPromise(1), getPromise(2)).pipe(
switchMap(([v1, v2]) => v1.getPromise(v2)) // map to nested Promise
)
Consulte la documentación o implementación para ver si el operador que está utilizando acepta ObservableInput
o SubscribableOrPromise
.
type ObservableInput<T> = SubscribableOrPromise<T> | ArrayLike<T> | Iterable<T>;
// Note the PromiseLike ----------------------------------------------------v
type SubscribableOrPromise<T> = Subscribable<T> | Subscribable<never> | PromiseLike<T> | InteropObservable<T>;
La diferencia entre from
y defer
en un ejemplo: https://stackblitz.com/edit/rxjs-6rb7vf
const getPromise = val => new Promise(resolve => {
console.log('Promise created for', val);
setTimeout(() => resolve(`Promise Resolved: ${val}`), 5000);
});
// the execution of getPromise('FROM') starts here, when you create the promise inside from
const fromPromise$ = from(getPromise('FROM'));
const deferPromise$ = defer(() => getPromise('DEFER'));
fromPromise$.subscribe(console.log);
// the execution of getPromise('DEFER') starts here, when you subscribe to deferPromise$
deferPromise$.subscribe(console.log);
from
método devuelve observable pero está enviando promesa como valor a las suscripciones. :(