Was ist die "callback-Hölle" und wie und warum tut RX es lösen?

1) Was ist ein "callback-Hölle" für jemanden, der nicht weiß, javascript und node.js ?

Diese andere Frage hat einige Beispiele von Javascript-callback-Hölle: Wie vermeiden Sie lange verschachtelte asynchrone Funktionen in Node.js

Das problem in Javascript ist, dass der einzige Weg, um "einfrieren" eine Berechnungs-und haben den "rest" ausführen letzteren (asynchron) zu legen, um "den rest" innerhalb einer callback.

Beispielsweise sagen, ich möchte code ausführen, der wie folgt aussieht:

x = getData();
y = getMoreData(x);
z = getMoreData(y);
...

Was passiert, wenn ich jetzt wollen die getData-Funktionen asynchron, was bedeutet, dass ich die chance bekommen, einige andere code, während ich warten, bis Sie zurückkehren, Ihre Werte? In Javascript, der einzige Weg wäre, um zu umschreiben, dass alles, was Sie berührt eine asynchrone Berechnung mit continuation-passing-style:

getData(function(x){
    getMoreData(x, function(y){
        getMoreData(y, function(z){ 
            ...
        });
    });
});

Glaube ich nicht, ich muss niemanden überzeugen, dass diese version ist hässlicher als die Vorherige. 🙂

2) Wann (in welcher Art von Einstellungen) ist die "callback-Hölle-problem" auftreten?

Wenn Sie haben viele von callback-Funktionen in Ihrem code! Es wird immer schwieriger, mit Ihnen zu arbeiten, die mehr von Ihnen, die Sie in Ihrem code und es wird besonders schlimm, wenn Sie brauchen, um do-Schleifen, try-catch-Blöcke und Dinge wie, dass.

Zum Beispiel, soweit ich weiß, in JavaScript die einzige Möglichkeit zum ausführen einer Reihe von asynchronen Funktionen, bei denen eine ausgeführt wird, nachdem die vorherigen zurückkehrt, ist mit einer rekursiven Funktion. Sie können nicht verwenden Sie eine for-Schleife.

//we would like to write the following
for(var i=0; i<10; i++){
    doSomething(i);
}
blah();

Statt, möglicherweise müssen wir am Ende schreiben:

function loop(i, onDone){
    if(i >= 10){
        onDone()
    }else{
        doSomething(i, function(){
            loop(i+1, onDone);
        });
     }
}
loop(0, function(){
    blah();
});

//ugh!

Die Anzahl der Fragen, die wir bekommen hier auf StackOverflow zu Fragen, wie das zu tun diese Art der Sache ist ein Beweis dafür, wie verwirrend es ist 🙂

3) Warum tritt es auf ?

Es tritt auf, da in JavaScript die einzige Möglichkeit, zu verzögern, eine Berechnung, so dass es ausgeführt wird, nachdem der asynchrone Aufruf zurückgegeben wird, ist der verzögerte code innerhalb einer callback-Funktion. Sie können keine Verzögerung code, der geschrieben wurde in der traditionellen synchronen Stil, so dass Sie am Ende mit verschachtelten callbacks überall.

4) Oder "callback-Hölle" kommen auch in einem single-threaded-Anwendung?

Asynchrone Programmierung zu tun hat mit der Parallelität während eine single-thread zu tun hat mit der Parallelität. Die beiden Begriffe sind eigentlich nicht das gleiche.

Können Sie noch gleichzeitigen code in einem single-threaded-Kontext. In der Tat, JavaScript, die Königin der callback-Hölle, ist single threaded.

Was ist der Unterschied zwischen Gleichzeitigkeit und Parallelität?

5) können Sie bitte auch zeigen, wie RX löst die "callback-Hölle-problem" auf, dass einfaches Beispiel.

Ich weiß nichts über die RX in allem, aber in der Regel dieses problem wird gelöst durch das hinzufügen von native support für die asynchrone Berechnung in der Programmiersprache. Die Implementierungen können variieren und umfassen: async, Generatoren, Coroutinen, und callcc.

In Python, die wir umsetzen können, der vorherigen Schleife zum Beispiel mit etwas entlang der Linien von:

def myLoop():
    for i in range(10):
        doSomething(i)
        yield

myGen = myLoop()

Dies ist nicht der vollständige code, sondern die Idee ist, dass die "Ausbeute" hält unsere for-Schleife, bis jemand fordert, myGen.next(). Das wichtigste ist, dass wir noch den code schreiben, der mittels einer for-Schleife ohne sich zu drehen Logik "inside out", wie wir zu tun hatten, dass rekursive loop Funktion.

Adresse der Frage, wie Rx löst callback-Hölle:

Lassen Sie uns zuerst beschreiben, callback-Hölle wieder.

Sich vorstellen, ein Fall wurden wir tun müssen http, um drei Ressourcen - Personen, planet und Galaxie. Unser Ziel ist es, die Galaxie, die person lebt in. Zuerst muss man die person, dann die Planeten, dann die Galaxie. Drei Rückrufe für drei asynchrone Operationen.

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

Jeden Rückruf geschachtelt ist. Jede innere callback ist abhängig von seinen Eltern. Dies führt zu der "pyramid of doom" - Stil der callback-Hölle. Der code sieht aus wie ein > sign.

Lösen diese in RxJs könnten Sie etwas wie das tun:

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

Mit der mergeMap AKA flatMap Betreiber könnte man es kurz und bündig:

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

Wie Sie sehen können, der code ist abgeflacht und enthält eine einzige Kette von Methodenaufrufen. Wir haben keine "pyramid of doom".

Daher, callback-Hölle vermieden wird.

Falls Sie sich Fragen, verspricht sind ein weiterer Weg, um zu vermeiden, callback-Hölle, aber die Versprechen eifrig, nicht faul wie observablen und (im Allgemeinen) Sie nicht Abbrechen kann Ihnen so leicht.

Wenn Sie nicht über ein wissen über Callbacks und callback-Hölle gibt es kein problem.Tritt der Sache ist, dass call back-und call-back-Hölle.Zum Beispiel:die Hölle zurück rufen ist wie ein können wir speichern eine Klasse in einer Klasse.Als Sie hörte, eingebettet in C, C++ - Sprache.Verschachtelt Bedeutet, dass eine Klasse in einer anderen Klasse.