Что такое "callback hell" и как и почему RX решает его?

просто ответьте на вопрос: не могли бы вы также показать, как RX решает "проблему обратного вызова ада" на этом простом примере?

магия flatMap. Мы можем написать следующий код в Rx для примера @hugomg:

def getData() = Observable[X]
getData().flatMap(x -> Observable[Y])
         .flatMap(y -> Observable[Z])
         .map(z -> ...)...

Это похоже на то, что вы пишете некоторые синхронные коды FP, но на самом деле вы можете сделать их асинхронными Scheduler.

Callback hell-это любой код, в котором использование обратных вызовов функций в асинхронном коде становится неясным или трудно следовать. Как правило, когда существует более одного уровня косвенности, код с использованием обратных вызовов может стать сложнее следовать, сложнее рефакторинг и сложнее тестировать. Запах кода-это несколько уровней отступа из-за передачи нескольких слоев литералов функций.

это часто происходит, когда поведение имеет зависимости, т. е. когда A должно произойти до B должно произойти раньше C. Затем вы получаете такой код:

a({
    parameter : someParameter,
    callback : function() {
        b({
             parameter : someOtherParameter,
             callback : function({
                 c(yetAnotherParameter)
        })
    }
});

Если у вас есть много поведенческих зависимостей кода, это может быть хлопотно быстро. Особенно если он ветвится...

a({
    parameter : someParameter,
    callback : function(status) {
        if (status == states.SUCCESS) {
          b(function(status) {
              if (status == states.SUCCESS) {
                 c(function(status){
                     if (status == states.SUCCESS) {
                         // Not an exaggeration. I have seen
                         // code that looks like this regularly.
                     }
                 });
              }
          });
        } elseif (status == states.PENDING {
          ...
        }
    }
});

Так не пойдет. Как мы можем заставить асинхронный код выполняться в определенном порядке без необходимости передавать все эти обратные вызовы?

RX-это сокращение от "реактивных расширений". Я не использовал его, но Googling предполагает, что это структура, основанная на событиях, что имеет смысл. события являются общим шаблоном для выполнения кода по порядку без создания хрупкой связи. Вы можете заставить C слушать событие "bFinished", которое происходит только после того, как B называется прослушиванием "aFinished". Затем вы можете легко добавить дополнительные шаги или расширить этот вид поведения, и может легко проверить что ваш код выполняется по порядку, просто транслируя события в вашем тестовом случае.

для решения вопроса о том, как Rx решает обратного вызова ад:

сначала давайте снова опишем ад обратного вызова.

представьте себе случай, когда мы должны сделать http, чтобы получить три ресурса - человек, планета и галактика. Наша цель-найти галактику, в которой живет человек. Сначала мы должны получить человека, затем планету, затем галактику. Это три обратных вызова для трех асинхронных операций.

getPerson(person => {
   getPlanet(person, (planet) => {
       getGalaxy(planet, (galaxy) => {
           console.log(galaxy);
       });
   });
});

каждый обратный вызов является вложенным. Каждый внутренний обратный вызов зависит от своего родителя. Это приводит к" пирамиде судьбы " стиль обратного вызова ад. Код выглядит как знак+.

чтобы решить эту проблему в RxJs вы могли бы сделать что-то вроде так:

getPerson()
  .map(person => getPlanet(person))
  .map(planet => getGalaxy(planet))
  .mergeAll()
  .subscribe(galaxy => console.log(galaxy));

С mergeMap АКА flatMap оператор вы могли бы сделать его более кратким:

getPerson()
  .mergeMap(person => getPlanet(person))
  .mergeMap(planet => getGalaxy(planet))
  .subscribe(galaxy => console.log(galaxy));

как вы можете видеть, код сглажен и содержит одну цепочку вызовов методов. У нас нет никакой"пирамиды обреченности".

следовательно, обратный вызов ад избежавший.

если вам интересно,обещания другой способ избежать обратного вызова ад, но обещания готовностью, а не лень как наблюдаемых, так и (вообще говоря) вы не можете отменить их так же легко.

использовать джаз.js https://github.com/Javanile/Jazz.js

Это упростить так:

    // run sequential task chained
    jj.script([
        // first task
        function(next) {
            // at end of this process 'next' point to second task and run it 
            callAsyncProcess1(next);
        },
      // second task
      function(next) {
        // at end of this process 'next' point to thirt task and run it 
        callAsyncProcess2(next);
      },
      // thirt task
      function(next) {
        // at end of this process 'next' point to (if have) 
        callAsyncProcess3(next);
      },
    ]);