blocks|key|407497|text|1)对于不懂javascript和node.js的人来说，什么是“回调地狱”？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|407498|另一个问题有一些Javascript回调地狱的例子：如何避免Node.js中异步函数的长嵌套|offset|length|407499|Javascript中的问题是，“冻结”计算并让“其余部分”执行后者(异步)的唯一方法是将“其余部分”放入回调中。|407500|例如，假设我想运行如下代码：|407501|x+=+getData();
y+=+getMoreData(x);
z+=+getMoreData(y);
...|code-block|syntax|javascript|407502|如果现在我想使getData函数异步化，这意味着我有机会在等待它们返回值时运行其他代码，那么会发生什么呢？在Javascript中，唯一的方法是使用延拓传递方式重写所有涉及异步计算的内容。|407503|getData(function(x){
++++getMoreData(x,+function(y){
++++++++getMoreData(y,+function(z){+
++++++++++++...
++++++++});
++++});
});|407504|我不认为我需要让任何人相信这个版本比前一个版本更丑。:-)|407505|2)“回调地狱问题”何时(在何种情况下)发生？|407506|当您的代码中有大量回调函数时！在代码中使用它们的难度越大，当您需要执行循环、尝试捕获块等操作时，情况就会变得特别糟糕。|407507|例如，据我所知，在JavaScript中，执行一系列异步函数的唯一方法是使用递归函数，其中一个是在前面返回之后运行的。你不能使用for循环。|407508|//+we+would+like+to+write+the+following
for(var+i=0;+i<10;+i%2B%2B){
++++doSomething(i);
}
blah();|407509|相反，我们可能最终需要写：|407510|function+loop(i,+onDone){
++++if(i+>=+10){
++++++++onDone()
++++}else{
++++++++doSomething(i,+function(){
++++++++++++loop(i%2B1,+onDone);
++++++++});
+++++}
}
loop(0,+function(){
++++blah();
});

//ugh!|407511|我们在StackOverflow上询问如何做这类事情的问题的数量证明了这是多么令人困惑:)|407512|(+3)为何会出现这种情况？|407513|这是因为在JavaScript中，延迟计算以便在异步调用返回后运行的唯一方法是将延迟的代码放入回调函数中。您不能延迟以传统同步样式编写的代码，因此您最终会在任何地方都使用嵌套回调。|407514|(+4)单线程应用程序是否也会出现“回调地狱”？|407515|异步编程与并发性有关，而单线程则与并行性有关。这两个概念实际上不是一回事。|407516|您仍然可以在单个线程上下文中拥有并发代码。事实上，JavaScript，回调地狱的女王，是单线程的。|407517|并发性和并行性有什么区别？|407518|5)请您也展示一下RX如何在这个简单的例子中解决“回调地狱问题”。|407519|我对RX并不了解，但通常通过在编程语言中添加对异步计算的本地支持来解决这个问题。实现可以不同，包括:异步、生成器、协同器和callcc。|407520|在Python中，我们可以使用以下内容来实现前面的循环示例：|407521|def+myLoop():
++++for+i+in+range(10):
++++++++doSomething(i)
++++++++yield

myGen+=+myLoop()|407522|这不是完整的代码，但思想是，“产生”暂停我们的for循环，直到有人调用myGen.next()。重要的是，我们仍然可以使用for循环编写代码，而不需要像在递归loop函数中所做的那样，将逻辑“内翻”。|style|CODE|407523|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/4234619/how-to-avoid-long-nesting-of-asynchronous-functions-in-node-js|1|https://duckduckgo.com/l/?kh=-1&uddg=https%253A%252F%252Fen.wikipedia.org%252Fwiki%252FContinuation-passing_style|2|https://stackoverflow.com/questions/1050222/concurrency-vs-parallelism-what-is-the-difference#1050257^0|0|Q|K|0|0|0|0|0|22|6|1|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|D|2|0|0|0|0|0|27|4|0^^$0|@$1|2|3|4|5|6|7|28|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|29|8|@]|9|@$D|2A|E|2B|1|2C]]|A|$]]|$1|F|3|G|5|6|7|2D|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|2E|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|2F|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|2G|8|@]|9|@$D|2H|E|2I|1|2J]]|A|$]]|$1|Q|3|R|5|L|7|2K|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|2L|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|2M|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|2N|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|2O|8|@]|9|@]|A|$]]|$1|10|3|11|5|L|7|2P|8|@]|9|@]|A|$M|N]]|$1|12|3|13|5|6|7|2Q|8|@]|9|@]|A|$]]|$1|14|3|15|5|L|7|2R|8|@]|9|@]|A|$M|N]]|$1|16|3|17|5|6|7|2S|8|@]|9|@]|A|$]]|$1|18|3|19|5|6|7|2T|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|6|7|2U|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|6|7|2V|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|6|7|2W|8|@]|9|@]|A|$]]|$1|1G|3|1H|5|6|7|2X|8|@]|9|@]|A|$]]|$1|1I|3|1J|5|6|7|2Y|8|@]|9|@$D|2Z|E|30|1|31]]|A|$]]|$1|1K|3|1L|5|6|7|32|8|@]|9|@]|A|$]]|$1|1M|3|1N|5|6|7|33|8|@]|9|@]|A|$]]|$1|1O|3|1P|5|6|7|34|8|@]|9|@]|A|$]]|$1|1Q|3|1R|5|L|7|35|8|@]|9|@]|A|$M|N]]|$1|1S|3|1T|5|6|7|36|8|@$D|37|E|38|1U|1V]]|9|@]|A|$]]|$1|1W|3|-4|5|6|7|39|8|@]|9|@]|A|$]]]|1X|$1Y|$5|1Z|20|21|A|$22|23]]|24|$5|1Z|20|21|A|$22|25]]|26|$5|1Z|20|21|A|$22|27]]]]

<h2>1) What is a "callback hell" for someone who does not know javascript and node.js ?</h2>

This other question has some examples of Javascript callback hell: <a href="https://stackoverflow.com/questions/4234619/how-to-avoid-long-nesting-of-asynchronous-functions-in-node-js">How to avoid long nesting of asynchronous functions in Node.js</a>

The problem in Javascript is that the only way to "freeze" a computation and have the "rest of it" execute latter (asynchronously) is to put "the rest of it" inside a callback.

For example, say I want to run code that looks like this:

<pre><code>x = getData();
y = getMoreData(x);
z = getMoreData(y);
...
</code></pre>

What happens if now I want to make the getData functions asynchronous, meaning that I get a chance to run some other code while I am waiting for them to return their values? In Javascript, the only way would be to rewrite everything that touches an async computation using <a href="https://duckduckgo.com/l/?kh=-1&amp;uddg=https%3A%2F%2Fen.wikipedia.org%2Fwiki%2FContinuation-passing_style" rel="noreferrer">continuation passing style</a>:

<pre><code>getData(function(x){
 getMoreData(x, function(y){
 getMoreData(y, function(z){ 
 ...
 });
 });
});
</code></pre>

I don't think I need to convince anyone that this version is uglier than the previous one. :-)

<h2>2) When (in what kind of settings) does the "callback hell problem" occur?</h2>

When you have lots of callback functions in your code! It gets harder to work with them the more of them you have in your code and it gets particularly bad when you need to do loops, try-catch blocks and things like that.

For example, as far as I know, in JavaScript the only way to execute a series of asynchronous functions where one is run after the previous returns is using a recursive function. You can't use a for loop.

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

Instead, we might need to end up writing:

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

//ugh!
</code></pre>

The number of questions we get here on StackOverflow asking how to do this kind of thing is a testament to how confusing it is :)

<h2>3) Why does it occur ?</h2>

It occurs because in JavaScript the only way to delay a computation so that it runs after the asynchronous call returns is to put the delayed code inside a callback function. You cannot delay code that was written in traditional synchronous style so you end up with nested callbacks everywhere.

<h2>4) Or can "callback hell" occur also in a single threaded application?</h2>

Asynchronous programming has to do with concurrency while a single-thread has to do with parallelism. The two concepts are actually not the same thing.

You can still have concurrent code in a single threaded context. In fact, JavaScript, the queen of callback hell, is single threaded.

<a href="https://stackoverflow.com/questions/1050222/concurrency-vs-parallelism-what-is-the-difference#1050257">What is the difference between concurrency and parallelism?</a>

<h2>5) could you please also show how RX solves the "callback hell problem" on that simple example.</h2>

I don't know anything about RX in particular, but usually this problem gets solved by adding native support for asynchronous computation in the programming language. The implementations can vary and include: async, generators, coroutines, and callcc. 

In Python we can implement that previous loop example with something along the lines of:

<pre><code>def myLoop():
 for i in range(10):
 doSomething(i)
 yield

myGen = myLoop()
</code></pre>

This is not the full code but the idea is that the "yield" pauses our for loop until someone calls myGen.next(). The important thing is that we could still write the code using a for loop, without needing to turn out logic "inside out" like we had to do in that recursive <code>loop</code> function.

blocks|key|407137|text|回调地狱是指在异步代码中使用函数回调变得模糊或难以理解的任何代码。通常，当有一个以上的间接方向时，使用回调的代码可能变得更难遵循，更难重构，更难测试。代码嗅觉是由于传递多个函数文本层而产生的多个缩进级别。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|407138|这种情况通常发生在行为有依赖关系时，即A必须发生在B之前，B必须发生在C之前。然后得到如下代码：|407139|a({
++++parameter+:+someParameter,
++++callback+:+function()+{
++++++++b({
+++++++++++++parameter+:+someOtherParameter,
+++++++++++++callback+:+function({
+++++++++++++++++c(yetAnotherParameter)
++++++++})
++++}
});|code-block|syntax|javascript|407140|如果您的代码中有很多行为依赖项，那么它会很快变得麻烦。尤其是如果它分支..。|407141|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+{
++++++++++...
++++++++}
++++}
});|407142|这样不行。我们如何使异步代码在不需要传递所有这些回调的情况下按确定的顺序执行？|407143|RX是“反应性扩展”的缩写。我没有使用它，但谷歌建议它是一个基于事件的框架，这是有意义的。事件是一种常见的模式，可以使代码按照顺序执行，而不会创建脆弱耦合的。您可以让C听事件'bFinished‘，这只有在B被称为听'aFinished’之后才会发生。然后，您可以轻松地添加额外的步骤或扩展这种行为，并且可以简单地通过在测试用例中广播事件来测试代码执行顺序的。|offset|length|style|BOLD|407144|entityMap^0|0|0|0|0|0|0|19|X|4Z|1|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|12|8|@$Q|13|R|14|S|T]|$Q|15|R|16|S|T]]|9|@]|A|$]]|$1|U|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|V|$]]

Callback hell is any code where the use of function callbacks in async code becomes obscure or difficult to follow. Generally, when there is more than one level of indirection, code using callbacks can become harder to follow, harder to refactor, and harder to test. A code smell is multiple levels of indentation due to passing multiple layers of function literals.

This often happens when behaviour has dependencies, i.e. when A must happen before B must happen before C. Then you get code like this:

<pre><code>a({
 parameter : someParameter,
 callback : function() {
 b({
 parameter : someOtherParameter,
 callback : function({
 c(yetAnotherParameter)
 })
 }
});
</code></pre>

If you have lots of behavioural dependencies in your code like this, it can get troublesome fast. Especially if it branches...

<pre><code>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 {
 ...
 }
 }
});
</code></pre>

This won't do. How can we make asynchronous code execute in a determined order without having to pass all these callbacks around?

RX is short for 'reactive extensions'. I haven't used it, but Googling suggests it's an event-based framework, which makes sense. Events are a common pattern to make code execute in order without creating brittle coupling. You can make C listen to the event 'bFinished' which only happens after B is called listening to 'aFinished'. You can then easily add extra steps or extend this kind of behaviour, and can easily test that your code executes in order by merely broadcasting events in your test case.

blocks|key|1139360|text|只需回答以下问题:请您也展示一下RX如何在这个简单的例子中解决“回调地狱问题”吗？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1139361|神奇的是flatMap。我们可以在Rx中为@hugomg的示例编写以下代码：|offset|length|style|CODE|1139362|def+getData()+=+Observable[X]
getData().flatMap(x+->+Observable[Y])
+++++++++.flatMap(y+->+Observable[Z])
+++++++++.map(z+->+...)...|code-block|syntax|javascript|1139363|这就好像您正在编写一些同步FP代码，但实际上您可以通过Scheduler使它们异步。|1139364|entityMap^0|0|4|7|0|0|R|9|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@$D|S|E|T|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|U|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|V|8|@$D|W|E|X|F|G]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|P|$]]

Just answer the question: could you please also show how RX solves the "callback hell problem" on that simple example?

The magic is <code>flatMap</code>. We can write the following code in Rx for @hugomg's example:

<pre><code>def getData() = Observable[X]
getData().flatMap(x -&gt; Observable[Y])
 .flatMap(y -&gt; Observable[Z])
 .map(z -&gt; ...)...
</code></pre>

It's like you are writing some synchronous FP codes, but actually you can make them asynchronous by <code>Scheduler</code>.

blocks|key|407155|text|解决Rx如何解决回调地狱的问题|type|unstyled|depth|inlineStyleRanges|entityRanges|data|407156|首先，让我们再来描述一下回调地狱。|407157|想象一下，如果我们必须做http来获得三种资源--人、行星和星系。我们的目标是找到那个人居住的星系。首先我们必须找到那个人，然后是行星，然后是银河系。这是三个异步操作的三个回调。|407158|getPerson(person+=>+{+
+++getPlanet(person,+(planet)+=>+{
+++++++getGalaxy(planet,+(galaxy)+=>+{
+++++++++++console.log(galaxy);
+++++++});
+++});
});|code-block|syntax|javascript|407159|每个回调都是嵌套的。每个内部回调都依赖于其父级。这导致了“厄运金字塔”式的回调地狱。代码看起来像是一个>符号。|407160|要在RxJ中解决这个问题，您可以这样做：|407161|getPerson()
++.map(person+=>+getPlanet(person))
++.map(planet+=>+getGalaxy(planet))
++.mergeAll()
++.subscribe(galaxy+=>+console.log(galaxy));|407162|使用mergeMap+AKA+flatMap运算符，您可以使其更加简洁：|offset|length|style|CODE|407163|getPerson()
++.mergeMap(person+=>+getPlanet(person))
++.mergeMap(planet+=>+getGalaxy(planet))
++.subscribe(galaxy+=>+console.log(galaxy));|407164|如您所见，代码是扁平的，包含一个方法调用链。我们没有“末日金字塔”。|407165|因此，避免了回调地狱。|407166|如果你想知道，承诺是另一种避免回调地狱的方法，但是承诺是热切的，不像可观察的那样懒惰，而且(一般来说)你不能轻易地取消它们。|407167|entityMap^0|0|0|0|0|0|0|0|2|8|F|7|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|18|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|19|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|1A|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1B|8|@]|9|@]|A|$]]|$1|O|3|P|5|H|7|1C|8|@]|9|@]|A|$I|J]]|$1|Q|3|R|5|6|7|1D|8|@$S|1E|T|1F|U|V]|$S|1G|T|1H|U|V]]|9|@]|A|$]]|$1|W|3|X|5|H|7|1I|8|@]|9|@]|A|$I|J]]|$1|Y|3|Z|5|6|7|1J|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|1K|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|1L|8|@]|9|@]|A|$]]|$1|14|3|-4|5|6|7|1M|8|@]|9|@]|A|$]]]|15|$]]

To address the question of how Rx solves callback hell:

First let's describe callback hell again.

Imagine a case were we must do http to get three resources - person, planet and galaxy. Our objective is to find the galaxy the person lives in. First we must get the person, then the planet, then the galaxy. That's three callbacks for three asynchronous operations.

<pre><code>getPerson(person =&gt; { 
 getPlanet(person, (planet) =&gt; {
 getGalaxy(planet, (galaxy) =&gt; {
 console.log(galaxy);
 });
 });
});
</code></pre>

Each callback is nested. Each inner callback is dependent on its parent. This leads to the "pyramid of doom" style of callback hell. The code looks like a > sign.

To solve this in RxJs you could do something like so:

<pre><code>getPerson()
 .map(person =&gt; getPlanet(person))
 .map(planet =&gt; getGalaxy(planet))
 .mergeAll()
 .subscribe(galaxy =&gt; console.log(galaxy));
</code></pre>

With the <code>mergeMap</code> AKA <code>flatMap</code> operator you could make it more succinct:

<pre><code>getPerson()
 .mergeMap(person =&gt; getPlanet(person))
 .mergeMap(planet =&gt; getGalaxy(planet))
 .subscribe(galaxy =&gt; console.log(galaxy));
</code></pre>

As you can see, the code is flattened and contains a single chain of method calls. We have no "pyramid of doom".

Hence, callback hell is avoided.

In case you were wondering, promises are another way to avoid callback hell, but promises are eager, not lazy like observables and (generally speaking) you cannot cancel them as easily.

blocks|key|1139451|text|如果您不了解回调和地狱回调，那么就没有problem.Ist了，问题是回调和回叫hell.For示例:地狱回调就像我们可以将一个类存储在你在C中听说过的一个class.As中，C%2B%2B+language.Nested意味着一个类在另一个类中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1139452|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

If you don't have a knowledge about callback and hell callback there is no problem.Ist thing is that call back and call back hell.For example:hell call back is like a we can store a class inside a class.As you heard about that nested in C, C++ language.Nested Means that a class inside a another class.

blocks|key|407607|text|一个方法可以避免回调地狱是使用玻璃钢，这是一个“增强型”的RX。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|407608|我最近开始使用玻璃钢，因为我发现它有一个很好的实现，叫做Sodium+(+http://sodium.nz/+)。|offset|length|style|CODE|407609|典型的代码如下所示(+Scala.js+)：|407610|def+render:+Unit+=>+VdomElement+=+{+_+=>
++<.div(
++++<.hr,
++++<.h2("Note+Selector"),
++++<.hr,
++++<.br,
++++noteSelectorTable.comp(),
++++NoteCreatorWidget().createNewNoteButton.comp(),
++++NoteEditorWidget(selectedNote.updates()).comp(),
++++<.hr,
++++<.br
++)
}|code-block|syntax|javascript|407611|selectedNote.updates()是一个Stream，如果selectedNode+(即Cell)发生变化，则NodeEditorWidget将相应更新。|407612|因此，根据selectedNode+Cell的内容，当前编辑的Note将发生变化。|407613|这段代码完全避免回调，几乎，Cacllback-s被推到应用程序的“外层”/“表面”，在该应用程序中，状态处理逻辑与外部世界接口。在内部状态处理逻辑(实现状态机)中传播数据不需要回调。|407614|完整的源代码是这里|407615|上面的代码片段会腐蚀以下简单的创建/显示/更新示例：|407616|​|407617|📷|atomic|407618|407619|此代码还将更新发送到服务器，因此对更新实体的更改将自动保存到服务器。|407620|所有的事件处理都是通过使用Streams和Cells来进行的，这些都是玻璃钢的概念。只有当FRP逻辑与外部世界接口时，才需要回调，如用户输入、编辑文本、按下按钮、AJAX调用返回。|407621|数据流以声明式方式使用FRP+(由钠库实现)进行显式描述，因此不需要事件处理/回调逻辑来描述数据流。|407622|FRP+(RX的一个更严格的版本)是描述数据流图的一种方法，它可以包含包含状态的节点。事件在包含节点的状态中触发状态更改(称为Cells)。|407623|钠是一个高阶的玻璃钢库，这意味着使用flatMap/switch原语可以在运行时重新排列数据流图。|407624|我建议查看一下钠书，它详细解释了玻璃钢如何消除所有回调，这些回调对于描述数据流逻辑是不重要的，因为这些回调与响应某些外部刺激更新应用程序状态有关。|407625|使用FRP，只需要保留那些描述与外部世界的交互作用的回调。换句话说，当使用FRP框架(如钠)或使用"FRP样“框架(如RX)时，数据流是以功能/声明方式描述的。|407626|钠也可用于Javascript/类型记录。|407627|entityMap|0|LINK|mutability|MUTABLE|url|http://sodium.nz/|1|http://github.com/jhegedus42/irie/blob/14240c5c46cea458cf3fc8f0f8996b3f6c2f41eb/modules/client/src/main/scala/client/ui/compositeWidgets/note/NoteCreateReadUpdateWidget.scala#L63-L63|2|IMAGE|IMMUTABLE|imageUrl|https://developer.qcloudimg.com/http-save/yehe-900000/d9df69595712202a4f45ffc686429863.png|imageAlt|3|https://livebook.manning.com/book/functional-reactive-programming/about-this-book/^0|0|S|6|11|H|0|0|0|0|0|M|P|6|Y|C|1D|4|1O|G|0|5|C|I|4|V|4|0|0|7|2|1|0|0|0|0|1|2|0|0|0|D|6|L|4|0|0|1R|4|0|I|7|Q|6|0|7|2|3|0|0|0^^$0|@$1|2|3|4|5|6|7|22|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|23|8|@$D|24|E|25|F|G]]|9|@$D|26|E|27|1|28]]|A|$]]|$1|H|3|I|5|6|7|29|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|2A|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|2B|8|@$D|2C|E|2D|F|G]|$D|2E|E|2F|F|G]|$D|2G|E|2H|F|G]|$D|2I|E|2J|F|G]|$D|2K|E|2L|F|G]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|2M|8|@$D|2N|E|2O|F|G]|$D|2P|E|2Q|F|G]|$D|2R|E|2S|F|G]]|9|@]|A|$]]|$1|S|3|T|5|6|7|2T|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|2U|8|@]|9|@$D|2V|E|2W|1|2X]]|A|$]]|$1|W|3|X|5|6|7|2Y|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|2Z|8|@]|9|@]|A|$]]|$1|10|3|11|5|12|7|30|8|@]|9|@$D|31|E|32|1|33]]|A|$]]|$1|13|3|Z|5|6|7|34|8|@]|9|@]|A|$]]|$1|14|3|15|5|6|7|35|8|@]|9|@]|A|$]]|$1|16|3|17|5|6|7|36|8|@$D|37|E|38|F|G]|$D|39|E|3A|F|G]]|9|@]|A|$]]|$1|18|3|19|5|6|7|3B|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|6|7|3C|8|@$D|3D|E|3E|F|G]]|9|@]|A|$]]|$1|1C|3|1D|5|6|7|3F|8|@$D|3G|E|3H|F|G]|$D|3I|E|3J|F|G]]|9|@]|A|$]]|$1|1E|3|1F|5|6|7|3K|8|@]|9|@$D|3L|E|3M|1|3N]]|A|$]]|$1|1G|3|1H|5|6|7|3O|8|@]|9|@]|A|$]]|$1|1I|3|1J|5|6|7|3P|8|@]|9|@]|A|$]]|$1|1K|3|-4|5|6|7|3Q|8|@]|9|@]|A|$]]]|1L|$1M|$5|1N|1O|1P|A|$1Q|1R]]|1S|$5|1N|1O|1P|A|$1Q|1T]]|1U|$5|1V|1O|1W|A|$1X|1Y|1Z|-4]]|20|$5|1N|1O|1P|A|$1Q|21]]]]

One way Callback hell can be avoided is to use FRP which is an "enhanced version" of RX. 

I started to use FRP recently because I have found a good implementation of it called <code>Sodium</code> ( <a href="http://sodium.nz/" rel="nofollow noreferrer">http://sodium.nz/</a> ). 

A typical code looks like this ( Scala.js ) : 

<pre><code>def render: Unit =&gt; VdomElement = { _ =&gt;
 &lt;.div(
 &lt;.hr,
 &lt;.h2("Note Selector"),
 &lt;.hr,
 &lt;.br,
 noteSelectorTable.comp(),
 NoteCreatorWidget().createNewNoteButton.comp(),
 NoteEditorWidget(selectedNote.updates()).comp(),
 &lt;.hr,
 &lt;.br
 )
}
</code></pre>

<code>selectedNote.updates()</code> is a <code>Stream</code> which fires if <code>selectedNode</code> (which is a <code>Cell</code>) changes, the <code>NodeEditorWidget</code> then updates correspondingly.

So, depending on the content of the <code>selectedNode</code> <code>Cell</code>, the currently edited <code>Note</code> will change.

This code avoids Callback-s entirely, almost, Cacllback-s are pushed to the "outer layer"/"surface" of the app, where the state handling logic interfaces with the external world. There are no Callbacks needed to propagate data within the internal state handling logic (which implements a state machine).

The full source code is <a href="http://github.com/jhegedus42/irie/blob/14240c5c46cea458cf3fc8f0f8996b3f6c2f41eb/modules/client/src/main/scala/client/ui/compositeWidgets/note/NoteCreateReadUpdateWidget.scala#L63-L63" rel="nofollow noreferrer">here</a>

The code snippet above corrosponds to the following simple Create / Display / Update example :

<a href="https://i.stack.imgur.com/7tlSx.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/7tlSx.png" alt="enter image description here"></a>

This code also sends updates to the server, so changes to the updated Entities are saved to the server automatically.

All the event handling is taken care by using <code>Stream</code>s and <code>Cell</code>s. These are FRP concepts. Callbacks are only needed where the FRP logic interfaces with the external world, such as user input, editing text, pressing a button, AJAX call returns. 

Data flow is explicitly described, in a declarative manner using FRP (implemented by the Sodium library), so no event handling / callback logic is needed to describe data flow.

FRP (which is a more "strict" version of RX) is a way to describe a data flow graph, which can contain nodes that contain state. Events trigger state changes in the state containing nodes (called <code>Cell</code>s). 

Sodium is a higher order FRP library, meaning that using the <code>flatMap</code>/<code>switch</code> primitive one can rearrange the data flow graph at runtime.

I recommend to have a look into the <a href="https://livebook.manning.com/book/functional-reactive-programming/about-this-book/" rel="nofollow noreferrer">Sodium book</a>, it explains in detail how FRP gets rid of all Callbacks which are not essential for describing dataflow logic that has to do with updating the applications state in response to some external stimuli. 

Using FRP, only those Callbacks need to be kept which describe interaction with the external world. In other words, the dataflow is described in a functional / declarative manner when one uses an FRP framework (such as Sodium), or when one uses an "FRP like" framework (such as RX).

Sodium is also available for Javascript/Typescript.

blocks|key|407301|text|回地狱意味着你在另一个回调的回调中，它会进入第九次呼叫，直到你不需要完全归档。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|407302|让我们通过一个使用set超时API的假ajax调用的例子来理解，假设我们有一个菜谱API，我们需要下载所有的菜谱。|407303|<body>
++++<script>
++++++++function+getRecipe(){
++++++++++++setTimeout(()=>{
++++++++++++++++const+recipeId+=+[83938,+73838,+7638];
++++++++++++++++console.log(recipeId);
++++++++++++},+1500);
++++++++}
++++++++getRecipe();
++++</script>
</body>|code-block|syntax|javascript|407304|在上面的例子中，当计时器过期1.5秒后，回调代码将执行，换句话说，通过我们伪造的ajax调用，所有配方都将从服务器下载。现在我们需要下载特定的食谱数据。|407305|<body>
++++<script>
++++++++function+getRecipe(){
++++++++++++setTimeout(()=>{
++++++++++++++++const+recipeId+=+[83938,+73838,+7638];
++++++++++++++++console.log(recipeId);
++++++++++++++++setTimeout(id=>{
++++++++++++++++++++const+recipe+=+{title:'Fresh+Apple+Juice',+publisher:'Suru'};
++++++++++++++++++++console.log(`${id}:+${recipe.title}`);
++++++++++++++++},+1500,+recipeId[2])
++++++++++++},+1500);
++++++++}
++++++++getRecipe();
++++</script>
</body>|407306|为了下载特定的菜谱数据，我们在第一个回调中编写了代码并传递了菜谱Id。|407307|现在，假设我们需要下载同一个菜谱出版商的所有菜谱，id为7638。|407308|<body>
++++<script>
++++++++function+getRecipe(){
++++++++++++setTimeout(()=>{
++++++++++++++++const+recipeId+=+[83938,+73838,+7638];
++++++++++++++++console.log(recipeId);
++++++++++++++++setTimeout(id=>{
++++++++++++++++++++const+recipe+=+{title:'Fresh+Apple+Juice',+publisher:'Suru'};
++++++++++++++++++++console.log(`${id}:+${recipe.title}`);
++++++++++++++++++++setTimeout(publisher=>{
++++++++++++++++++++++++const+recipe2+=+{title:'Fresh+Apple+Pie',+publisher:'Suru'};
++++++++++++++++++++++++console.log(recipe2);
++++++++++++++++++++},+1500,+recipe.publisher);
++++++++++++++++},+1500,+recipeId[2])
++++++++++++},+1500);
++++++++}
++++++++getRecipe();
++++</script>
</body>|407309|为了充分满足我们的需求，也就是下载出版商名suru的所有菜谱，我们在第二次回叫中编写了代码。很明显，我们写了一个回调链，称为回调地狱。|407310|如果您想要避免回调地狱，您可以使用承诺，这是js+es6特性，每个承诺接受一个回调，当一个承诺是满的时候调用。“承诺回调”有两个选项，要么已解决，要么拒绝。假设您的API调用是成功的，您可以调用解析并通过传递数据，您可以使用然后()来获取这些数据。但是，如果您的API失败了，您可以使用拒绝，使用+catch+来捕获错误。记住，承诺总是使用，然后使用表示解决，捕捉作为拒绝。|offset|length|style|BOLD|407311|让我们用承诺来解决以前的回调地狱问题。|407312|<body>
++++<script>

++++++++const+getIds+=+new+Promise((resolve,+reject)=>{
++++++++++++setTimeout(()=>{
++++++++++++++++const+downloadSuccessfull+=+true;
++++++++++++++++const+recipeId+=+[83938,+73838,+7638];
++++++++++++++++if(downloadSuccessfull){
++++++++++++++++++++resolve(recipeId);
++++++++++++++++}else{
++++++++++++++++++++reject('download+failed+404');
++++++++++++++++}
++++++++++++},+1500);
++++++++});

++++++++getIds.then(IDs=>{
++++++++++++console.log(IDs);
++++++++}).catch(error=>{
++++++++++++console.log(error);
++++++++});
++++</script>
</body>|407313|现在下载特定的菜谱：|407314|<body>
++++<script>
++++++++const+getIds+=+new+Promise((resolve,+reject)=>{
++++++++++++setTimeout(()=>{
++++++++++++++++const+downloadSuccessfull+=+true;
++++++++++++++++const+recipeId+=+[83938,+73838,+7638];
++++++++++++++++if(downloadSuccessfull){
++++++++++++++++++++resolve(recipeId);
++++++++++++++++}else{
++++++++++++++++++++reject('download+failed+404');
++++++++++++++++}
++++++++++++},+1500);
++++++++});

++++++++const+getRecipe+=+recID+=>+{
++++++++++++return+new+Promise((resolve,+reject)=>{
++++++++++++++++setTimeout(id+=>+{
++++++++++++++++++++const+downloadSuccessfull+=+true;
++++++++++++++++++++if+(downloadSuccessfull){
++++++++++++++++++++++++const+recipe+=+{title:'Fresh+Apple+Juice',+publisher:'Suru'};
++++++++++++++++++++++++resolve(`${id}:+${recipe.title}`);
++++++++++++++++++++}else{
++++++++++++++++++++++++reject(`${id}:+recipe+download+failed+404`);
++++++++++++++++++++}

++++++++++++++++},+1500,+recID)
++++++++++++})
++++++++}
++++++++getIds.then(IDs=>{
++++++++++++console.log(IDs);
++++++++++++return+getRecipe(IDs[2]);
++++++++}).
++++++++then(recipe+=>{
++++++++++++console.log(recipe);
++++++++})
++++++++.catch(error=>{
++++++++++++console.log(error);
++++++++});
++++</script>
</body>|407315|现在，我们可以编写另一个调用allRecipeOfAPublisher的方法，如getRecipe，它也将返回一个承诺，我们还可以编写另一个()来接收allRecipeOfAPublisher的解析承诺，我希望此时您可以自己完成。|407316|因此，我们学习了如何构建和使用承诺，现在让我们通过使用es8中引入的异步/等待更容易地使用承诺。|407317|<body>
++++<script>

++++++++const+getIds+=+new+Promise((resolve,+reject)=>{
++++++++++++setTimeout(()=>{
++++++++++++++++const+downloadSuccessfull+=+true;
++++++++++++++++const+recipeId+=+[83938,+73838,+7638];
++++++++++++++++if(downloadSuccessfull){
++++++++++++++++++++resolve(recipeId);
++++++++++++++++}else{
++++++++++++++++++++reject('download+failed+404');
++++++++++++++++}
++++++++++++},+1500);
++++++++});

++++++++const+getRecipe+=+recID+=>+{
++++++++++++return+new+Promise((resolve,+reject)=>{
++++++++++++++++setTimeout(id+=>+{
++++++++++++++++++++const+downloadSuccessfull+=+true;
++++++++++++++++++++if+(downloadSuccessfull){
++++++++++++++++++++++++const+recipe+=+{title:'Fresh+Apple+Juice',+publisher:'Suru'};
++++++++++++++++++++++++resolve(`${id}:+${recipe.title}`);
++++++++++++++++++++}else{
++++++++++++++++++++++++reject(`${id}:+recipe+download+failed+404`);
++++++++++++++++++++}

++++++++++++++++},+1500,+recID)
++++++++++++})
++++++++}

++++++++async+function+getRecipesAw(){
++++++++++++const+IDs+=+await+getIds;
++++++++++++console.log(IDs);
++++++++++++const+recipe+=+await+getRecipe(IDs[2]);
++++++++++++console.log(recipe);
++++++++}

++++++++getRecipesAw();
++++</script>
</body>|407318|在上面的示例中，我们使用了异步函数，因为它将在后台运行，在异步函数中，我们在返回或承诺的每个方法之前使用了等待关键字，因为要等待该位置直到该承诺实现，换句话说，在下面的代码中，直到getIds完成解析或拒绝程序将停止执行id返回时位于该行下方的代码，然后使用id再次调用getRecipe()函数，并使用wait关键字等待直到数据返回。所以这就是我们最终从回调地狱中恢复过来的方式。|407319|++async+function+getRecipesAw(){
++++++++++++const+IDs+=+await+getIds;
++++++++++++console.log(IDs);
++++++++++++const+recipe+=+await+getRecipe(IDs[2]);
++++++++++++console.log(recipe);
++++++++}|407320|要使用等待，我们将需要一个异步函数，我们可以返回一个承诺，然后用于解决承诺，而cath则用于拒绝承诺。|407321|从上面的例子：|407322|+async+function+getRecipesAw(){
++++++++++++const+IDs+=+await+getIds;
++++++++++++const+recipe+=+await+getRecipe(IDs[2]);
++++++++++++return+recipe;
++++++++}

++++++++getRecipesAw().then(result=>{
++++++++++++console.log(result);
++++++++}).catch(error=>{
++++++++++++console.log(error);
++++++++});|407323|entityMap^0|0|0|0|0|0|0|0|0|0|34|4|44|7|4Q|5|50|2|0|0|0|0|0|E|L|0|0|0|1H|2|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|1T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|1U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|1V|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1W|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|1X|8|@]|9|@]|A|$G|H]]|$1|S|3|T|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1Z|8|@$W|20|X|21|Y|Z]|$W|22|X|23|Y|Z]|$W|24|X|25|Y|Z]|$W|26|X|27|Y|Z]]|9|@]|A|$]]|$1|10|3|11|5|6|7|28|8|@]|9|@]|A|$]]|$1|12|3|13|5|F|7|29|8|@]|9|@]|A|$G|H]]|$1|14|3|15|5|6|7|2A|8|@]|9|@]|A|$]]|$1|16|3|17|5|F|7|2B|8|@]|9|@]|A|$G|H]]|$1|18|3|19|5|6|7|2C|8|@$W|2D|X|2E|Y|Z]]|9|@]|A|$]]|$1|1A|3|1B|5|6|7|2F|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|F|7|2G|8|@]|9|@]|A|$G|H]]|$1|1E|3|1F|5|6|7|2H|8|@$W|2I|X|2J|Y|Z]]|9|@]|A|$]]|$1|1G|3|1H|5|F|7|2K|8|@]|9|@]|A|$G|H]]|$1|1I|3|1J|5|6|7|2L|8|@]|9|@]|A|$]]|$1|1K|3|1L|5|6|7|2M|8|@]|9|@]|A|$]]|$1|1M|3|1N|5|F|7|2N|8|@]|9|@]|A|$G|H]]|$1|1O|3|-4|5|6|7|2O|8|@]|9|@]|A|$]]]|1P|$]]

Call back hell means you are inside of a callback of inside another callback and it goes to nth call until your needs not fullfiled.

Let's understand through an example of fake ajax call by using set timeout API, lets assume we have a recipe API, we need to download all recipe.

<pre><code>&lt;body&gt;
 &lt;script&gt;
 function getRecipe(){
 setTimeout(()=&gt;{
 const recipeId = [83938, 73838, 7638];
 console.log(recipeId);
 }, 1500);
 }
 getRecipe();
 &lt;/script&gt;
&lt;/body&gt;
</code></pre>

In the above example after 1.5 sec when timer expires inside code of call back will execute, in other words, through our fake ajax call all recipe will downloaded from the server. Now we need to download a particular recipe data.

<pre><code>&lt;body&gt;
 &lt;script&gt;
 function getRecipe(){
 setTimeout(()=&gt;{
 const recipeId = [83938, 73838, 7638];
 console.log(recipeId);
 setTimeout(id=&gt;{
 const recipe = {title:'Fresh Apple Juice', publisher:'Suru'};
 console.log(`${id}: ${recipe.title}`);
 }, 1500, recipeId[2])
 }, 1500);
 }
 getRecipe();
 &lt;/script&gt;
&lt;/body&gt;
</code></pre>

To download a particular recipe data we wrote code inside of our first callback and passed recipe Id.

Now let's say we need to download all the recipes of the same publisher of the recipe which id is 7638.

<pre><code>&lt;body&gt;
 &lt;script&gt;
 function getRecipe(){
 setTimeout(()=&gt;{
 const recipeId = [83938, 73838, 7638];
 console.log(recipeId);
 setTimeout(id=&gt;{
 const recipe = {title:'Fresh Apple Juice', publisher:'Suru'};
 console.log(`${id}: ${recipe.title}`);
 setTimeout(publisher=&gt;{
 const recipe2 = {title:'Fresh Apple Pie', publisher:'Suru'};
 console.log(recipe2);
 }, 1500, recipe.publisher);
 }, 1500, recipeId[2])
 }, 1500);
 }
 getRecipe();
 &lt;/script&gt;
&lt;/body&gt;
</code></pre>

To full-fill our needs which is to download all the recipes of publisher name suru, we wrote code inside of our second call back. It is clear we wrote a callback chain which is called callback hell.

If you want to avoid callback hell, you can use Promise, which is js es6 feature, each promise takes a callback which is called when a promise is full-filled. promise callback has two options either it is resolved or reject. Suppose your API call is successful you can call resolve and pass data through the resolve, you can get this data by using then(). But if your API failed you can use reject, use catch to catch the error. Remember a promise always use then for resolve and catch for reject 

Let's solve the previous callback hell problem using a promise.

<pre><code>&lt;body&gt;
 &lt;script&gt;

 const getIds = new Promise((resolve, reject)=&gt;{
 setTimeout(()=&gt;{
 const downloadSuccessfull = true;
 const recipeId = [83938, 73838, 7638];
 if(downloadSuccessfull){
 resolve(recipeId);
 }else{
 reject('download failed 404');
 }
 }, 1500);
 });

 getIds.then(IDs=&gt;{
 console.log(IDs);
 }).catch(error=&gt;{
 console.log(error);
 });
 &lt;/script&gt;
&lt;/body&gt;
</code></pre>

Now download particular recipe:

<pre><code>&lt;body&gt;
 &lt;script&gt;
 const getIds = new Promise((resolve, reject)=&gt;{
 setTimeout(()=&gt;{
 const downloadSuccessfull = true;
 const recipeId = [83938, 73838, 7638];
 if(downloadSuccessfull){
 resolve(recipeId);
 }else{
 reject('download failed 404');
 }
 }, 1500);
 });

 const getRecipe = recID =&gt; {
 return new Promise((resolve, reject)=&gt;{
 setTimeout(id =&gt; {
 const downloadSuccessfull = true;
 if (downloadSuccessfull){
 const recipe = {title:'Fresh Apple Juice', publisher:'Suru'};
 resolve(`${id}: ${recipe.title}`);
 }else{
 reject(`${id}: recipe download failed 404`);
 }

 }, 1500, recID)
 })
 }
 getIds.then(IDs=&gt;{
 console.log(IDs);
 return getRecipe(IDs[2]);
 }).
 then(recipe =&gt;{
 console.log(recipe);
 })
 .catch(error=&gt;{
 console.log(error);
 });
 &lt;/script&gt;
&lt;/body&gt;
</code></pre>

Now we can write another method call allRecipeOfAPublisher like getRecipe which will also return a promise, and we can write another then() to receive resolve promise for allRecipeOfAPublisher, I hope at this point you can do it by yourself.

So we learned how to construct and consumed promises, now let's make consuming a promise easier by using async/await which is introduced in es8.

<pre><code>&lt;body&gt;
 &lt;script&gt;

 const getIds = new Promise((resolve, reject)=&gt;{
 setTimeout(()=&gt;{
 const downloadSuccessfull = true;
 const recipeId = [83938, 73838, 7638];
 if(downloadSuccessfull){
 resolve(recipeId);
 }else{
 reject('download failed 404');
 }
 }, 1500);
 });

 const getRecipe = recID =&gt; {
 return new Promise((resolve, reject)=&gt;{
 setTimeout(id =&gt; {
 const downloadSuccessfull = true;
 if (downloadSuccessfull){
 const recipe = {title:'Fresh Apple Juice', publisher:'Suru'};
 resolve(`${id}: ${recipe.title}`);
 }else{
 reject(`${id}: recipe download failed 404`);
 }

 }, 1500, recID)
 })
 }

 async function getRecipesAw(){
 const IDs = await getIds;
 console.log(IDs);
 const recipe = await getRecipe(IDs[2]);
 console.log(recipe);
 }

 getRecipesAw();
 &lt;/script&gt;
&lt;/body&gt;
</code></pre>

In the above example, we used an async function because it will run in the background, inside async function we used await keyword before each method which returns or is a promise because to wait on that position until that promise fulfilled, in other words in the bellow codes until getIds completed resolved or reject program will stop executing codes bellow that line when IDs returned then we again called getRecipe() function with a id and waited by using await keyword until data returned. So this is how finally we recovered from the callback hell.

<pre><code> async function getRecipesAw(){
 const IDs = await getIds;
 console.log(IDs);
 const recipe = await getRecipe(IDs[2]);
 console.log(recipe);
 }
</code></pre>

To use await we will need a async function, we can return a promise so use then for resolve promise and cath for reject promise

from the above example:

<pre><code> async function getRecipesAw(){
 const IDs = await getIds;
 const recipe = await getRecipe(IDs[2]);
 return recipe;
 }

 getRecipesAw().then(result=&gt;{
 console.log(result);
 }).catch(error=&gt;{
 console.log(error);
 });
</code></pre>

Can someone give a clear definition together with a simple example that explains what is a "callback hell" for someone who does not know JavaScript and node.js ?

When (in what kind of settings) does the "callback hell problem" occur? 

Why does it occur?

Is "callback hell" always related to asynchronous computations? 

Or can "callback hell" occur also in a single threaded application? 

I took the Reactive Course at Coursera and Erik Meijer said in one of his lectures that RX solves the problem of "callback hell". I asked what is a "callback hell" on the Coursera forum but I got no clear answer. 

After explaining "callback hell" on a simple example, could you also show how RX solves the "callback hell problem" on that simple example?

What is "callback hell" and how and why does RX solve it?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

有人能给出一个明确的定义和一个简单的例子来解释什么是不懂JavaScript和node.js的人的“回调地狱”吗？什么时候(在什么样的设置中)会出现“回调地狱问题”？为什么会发生这种情况？“回调地狱”总是与异步计算相关吗？或者“回调地狱”也会出现在单个线程应用程序中吗？我参加了古瑟拉的反应课程，埃里克·梅耶尔在他的一次...

问什么是“回调地狱”？RX如何以及为什么要解决这个问题？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么是“回调地狱”？RX如何以及为什么要解决这个问题？EN