康卡特可观察物重用以前的结果

Question

Imagine I have 3 functions, taking some arguments and returning an observable. Logic would be (all would be a result of something async):

1. Get a cat.
2. Pet the cat.
3. Get food for the cat based on it's mood after petting it.

Sample code:

function getCat(): Observable<Cat> {
  return Observable.of({ name: 'Larry' }) 
}

function petCat(cat: Cat): Observable<Mood> {
  return Observable.of(Mood.HAPPY)
}

function getFood(cat: Cat, mood: Mood): Observable<Food> {
  return Observable.of({ type: 'fish' })
}

1. I would like to end up with an Observable that's equivalent with this:

   Observable.from([{ name: 'Larry' }, Mood.HAPPY, { type: 'fish' }])

2. I would like the functions to be invoked in sequence (obviously from the parameter signatures)

3. I would not like to delay the individual emits, in the final observable I'd like to get the results as soon as they arrive.

I could get it working with something like this:

function perform() {
  return getCat().pipe(
    mergeMap((cat) => concat(
        of(cat),
        petCat(cat).pipe(
          mergeMap((mood) => concat(
            of(mood),
            getFood(cat, mood)
          ))
        )
      )
    ),
  )
}

Question is , is there a better, more readable way of doing this (let's say I would have 5 of these that I would like to chain)?

Answer 1

You can try something like

getCat()
.pipe(
   switchMap(cat => petCat(cat).pipe(map(mood => ({cat, mood})))),
   switchMap(({cat, mood}) => getFood(cat, mood))
)

The whole idea is to use switchMap to switch from the source Observable to the Observable returned by the function passed to switchMap as parameter.

Maybe worth of mentioning is the use of map chained into the pipe of the first switchMap . That map operator makes sure that we keep cat as part of the parameters we pass the second, and last, switchMap .

UPDATE after comment If the function perform has to emit all the 3 elements emitted by the 3 functions, then you may try something like the following

function perform() {
   return getCat()
          .pipe(
             switchMap(cat => petCat(cat).pipe(map(mood => ({cat, mood})))),
             switchMap(({cat, mood}) => getFood(cat, mood).pipe(map(food => ({cat, mood, food}))))
          )
}