Operadores de transformación o aplanamiento (Flattening Operators)

Los operadores de transformación o aplanamiento reciben un observable y se suscriben a este de manera interna.
Este tipo de operadores son necesarios cuando tenemos un observable dentro de otro observable, el cual necesitariamos suscribirnos dentro de la suscripción para poder recibir los valores, dicho proceso seria un poco dificil de leer y de mantener.

• mergeAll: Este operador se suscribe a los observables emitidos por el source, y esta pendiente de ellos, nos devolveria las emisiones de todas las suscripciones internas en un única suscripción. No se completaria hasta que todas las suscripciones a las que esta suscrito se completen. Puede recibir un argumento que es el número de observables internos a los que se suscribira, por defecto es Infinito. mergeAll()
• mergeMap: Se llama con un callBack: mergeMap( () => ). Este operador funciona de igual manera que el mergeAll, la diferencia es que este puede transformar los valores de las suscripciones internas, al igual que switchMap, concatMap y exhaustMap

mergeMap(x => x * 5)
--------
mergeMap(() => interval(1000))

• switchMap: Se llama con un callBack: switchMap( () => ). Es igual que el mergeMap, con la única diferencia que mientras que el mergeMap puede mantener infinitas suscripciones internas, el switchMap solamente estará suscrito al más reciente. Es decir si tenemos una suscripción interna a un interval y nos entra otro valor del source, ese intervalo se completaria y pasaría a emitir los valores del último interval. Muy útil para las peticiones AJAX.
• concatMap: Se llama con un callBack: concatMap( () => ). Los observables a los que se suscribe internamente pasan inmediatamente a la salida, pero si entra un nuevo observable al que debe suscribirse, este lo pondria en la cola hasta que el observable al que está suscrito se completase, en ese momento se suscribiria y empezaria a emitir esos valores.
• exhaustMap: Se llama con un callBack: exhaustMap( () => ). A diferencia del concatMap, si este recibe un nuevo observable al que suscribirse y ya tiene activa una suscripción lo va a ignorar completamente, para que este operador se suscriba internamente a otro observable, no tiene que tener ninguno activo en ese preciso momento.