¿Por qué necesitamos usar flatMap?

['a','b','c'].flatMap(function(e) {
    return [e, e+ 'x', e+ 'y',  e+ 'z'  ];
});
//['a', 'ax', 'ay', 'az', 'b', 'bx', 'by', 'bz', 'c', 'cx', 'cy', 'cz']


['a','b','c'].map(function(e) {
    return [e, e+ 'x', e+ 'y',  e+ 'z'  ];
});
//[Array[4], Array[4], Array[4]]

Se usa flatMap cuando se tiene un Observable cuyos resultados son más Observables.

Si tiene un observable que es producido por otro observable, no puede filtrarlo, reducirlo o mapearlo directamente porque tiene un Observable no los datos. Si produce un observable, elija flatMap sobre map; entonces está bien.

Al igual que en el segundo fragmento, si está haciendo una operación asincrónica, debe usar Mapa plano.

var source = Rx.Observable.interval(100).take(10).map(function(num){
    return num+1
});
source.subscribe(function(e){
    console.log(e)
})

<script src="https://cdnjs.cloudflare.com/ajax/libs/rxjs/5.4.1/Rx.min.js"></script>

var source = Rx.Observable.interval(100).take(10).flatMap(function(num){
    return Rx.Observable.timer(100).map(() => num)
});
source.subscribe(function(e){
    console.log(e)
})

<script src="https://cdnjs.cloudflare.com/ajax/libs/rxjs/5.4.1/Rx.min.js"></script>

flatMap transformar los elementos emitidos por un Observable en nuevos Observables, luego aplana las emisiones de esos en un solo Observable.

Echa un vistazo al siguiente escenario donde get("posts") devuelve un Observable que está "aplanado" por flatMap.

myObservable.map(e => get("posts")).subscribe(o => console.log(o));
// this would log Observable objects to console.  

myObservable.flatMap(e => get("posts")).subscribe(o => console.log(o));
// this would log posts to console.

No es una matriz de matrices. Es un observable de observable (s).

Lo siguiente devuelve un flujo observable de cadena.

requestStream
  .map(function(requestUrl) {
    return requestUrl;
  });

Mientras que esto devuelve un flujo observable de flujo observable de json

requestStream
  .map(function(requestUrl) {
    return Rx.Observable.fromPromise(jQuery.getJSON(requestUrl));
  });

flatMap aplana el observable automáticamente para nosotros para que podamos observar el flujo json directamente

Un Observable es un objeto que emite una secuencia de eventos: Siguiente, Error y Completado.

Cuando su función devuelve un Observable, no devuelve un flujo, sino una instancia de Observable. El operador flatMap simplemente asigna esa instancia a una secuencia.

Ese es el comportamiento de flatMap cuando se compara con map: Ejecuta la función dada y aplana el objeto resultante en una secuencia.

Simple:

[1,2,3].map(x => [x, x * 10])
// [[1, 10], [2, 20], [3, 30]]

[1,2,3].flatMap(x => [x, x * 10])
// [1, 10, 2, 20, 3, 30]]

La gente tiende a complicar las cosas dando la definición que dice:

FlatMap transforma los elementos emitidos por un Observable en Observables, a continuación, aplanar las emisiones de los mismos en un solo Observable

Juro que esta definición todavía me confunde, pero voy a explicarla de la manera más simple, que es usando un ejemplo

Nuestra situación : tenemos un observable que devuelve datos (URL simple) que vamos a úselo para hacer una llamada HTTP que devolverá un observable que contenga los datos que necesitamos para que pueda visualizar la situación de esta manera:

Observable 1
    |_
       Make Http Call Using Observable 1 Data (returns Observable_2)
            |_
               The Data We Need

Así que como se puede ver no podemos llegar a los datos que necesitamos directamente por lo que la primera forma de recuperar los datos que podemos utilizar sólo suscripciones normales como esta:

Observable_1.subscribe((URL) => {
         Http.get(URL).subscribe((Data_We_Need) => {
                  console.log(Data_We_Need);
          });
});

Esto funciona, pero como puede ver, tenemos que anidar suscripciones para obtener nuestros datos. esto actualmente no se ve mal, pero imagine que tenemos 10 suscripciones anidadas que se convertirían en inalcanzable.

Así que una mejor manera de manejar esto es usar el operador flatMap que hará lo mismo pero nos hace evitar esa suscripción anidada:

Observable_1
    .flatMap(URL => Http.get(URL))
    .subscribe(Data_We_Need => console.log(Data_We_Need));

Con flatMap

var requestStream = Rx.Observable.just('https://api.github.com/users');

var responseMetastream = requestStream
  .flatMap(function(requestUrl) {
    return Rx.Observable.fromPromise(jQuery.getJSON(requestUrl));
  });

responseMetastream.subscribe(json => {console.log(json)})

Sin Mapa plano

var requestStream = Rx.Observable.just('https://api.github.com/users');

var responseMetastream = requestStream
  .map(function(requestUrl) {
    return Rx.Observable.fromPromise(jQuery.getJSON(requestUrl));
  });

responseMetastream.subscribe(jsonStream => {
  jsonStream.subscribe(json => {console.log(json)})
})

Aquí para mostrar la implementación equivalente de un mapa plano utilizando subscribes.

Sin Mapa plano:

this.searchField.valueChanges.debounceTime(400)
.subscribe(
  term => this.searchService.search(term)
  .subscribe( results => {
      console.log(results);  
      this.result = results;
    }
  );
);

Con Mapa plano:

this.searchField.valueChanges.debounceTime(400)
    .flatMap(term => this.searchService.search(term))
    .subscribe(results => {
      console.log(results);
      this.result = results;
    });

Http://plnkr.co/edit/BHGmEcdS5eQGX703eRRE?p=preview

Espero que pueda ayudar.