Question

我倾向于害怕为除了相对微不足道的功能之外的任何东西编写Javascript的原因之一是我从来没有找到一个合适的方法来避免回调瀑布，当一件事真的依赖于另一件事。有没有这样的方法？

我现在正在开发一款Titanium应用程序，并进入这个现实世界的场景：

我有一套设施，我需要计算距离用户当前位置的距离。这需要获取用户的当前位置（仅需要发生一次），并且在环绕设施位置时，获取每个位置并计算距离。检索位置（长/纬）的API是异步的，因此“简单”方法看起来像这样（伪代码如下）：

foreach facility {
  API.getCurrentLocation( function( location ) { // async, takes a callback fxn arg
    var here = location.coordinates;

    API.getFacilityLocation( function( e ) { // async, takes a callback fxn arg
      var there    = e. coordinates;
      var distance = API.calculateFrom( here, there );
    });
  });
}

因为这只是一个循环，但我每次都在计算我当前的位置 - 比我真正需要做的更多的工作。我还没有设法以这样的方式对其进行重构：我只获取当前位置一次，并且仍然可以将该位置用于距离计算。

鉴于支持lambdas和闭包的语言激增，我一直认为有人必须找到一种方法来保持这些瀑布的可管理性，但我还没有找到如何组织这种解决方案的良好解释。

有任何建议或提示吗？

非常感谢任何见解。

Answer 1

基本策略：不要使用匿名函数进行回调，并将循环移动到返回当前位置时运行的回调。

示例：

function recieveCurrentLocation(location) { // async, takes a callback fxn arg
    var here = location.coordinates;

    // Have to define this callback in the inner scope so it can close
    // over the 'here' value
    function recieveFacilityLocation(e) {
        var there    = e. coordinates;
        var distance = API.calculateFrom( here, there );
    }

    foreach facility {
        API.getFacilityLocation(recieveFacilityLocation);
    }
}

API.getCurrentLocation(recieveCurrentLocation);

Answer 2

你必须开始考虑更多以事件为导向。定义每个回调级别的函数，并在需要时将其作为参数提供，并且不要将其视为回调瀑布。请注意，在每个非批处理过程中都有相同的内容：等待用户操作，有一个运行操作的大事件循环，等待其他用户操作，运行另一个事件处理操作等。

简单地完成目前可以完成的任务以及任何异步寄存器处理程序。来自计算机系统的用户操作和异步响应并没有那么不同：）

Answer 3

这里有两个不同的问题。第一个是嵌套回调（以“watterfall”方式），第二个是调用异步函数，而不知道你想要传递什么。

为了避免嵌套地狱，基本思路是使用名称功能。所以

f1(arg1, function(){
    arg2 = g(arg1);
    f2(function(){
        ...use arg2
    });
});

可以成为

var arg2;
f1(arg1, afterf1);

function afterf1(){
    arg2 = g(arg1);
    f2(afterf2);
}

function afterf2(){
    ...use arg2;
}

请注意，唯一的另一个主要重构是我们需要将内部函数关闭的所有变量移动到外部作用域，因为内部函数不再是内部函数（尽量保持共享变量的最小值） - 如果你觉得你开始得到太多的代码，有许多技巧可以将它们重构成更多可编辑的代码。）

现在，另一个问题是当您使用的值时，您不知道回调。

在同步的情况下，你可以做到

var x = f();

任何想要x的人都可以随时随地访问它。

但在异步的情况下，你只能做

f(function(x){
   ...use x here
});

唯一能够看到x的代码将由此回调控制。

然后有一种方法可以在之后添加额外的“真实”回调，并将传递给原始函数的回调只传递给感兴趣的各方，而不是直接使用它。

var got_result = false;
var result = null;
var waiting_for_result = [];

function register_callback(f){
    if(got_result){
        f(result);
    }else{
        waiting_for_result.push(f);
    }
}

var real_callback = function(x){
    got_result = true;
    result = x;
    for(var i=0; i< waiting_for_result.length; i++){
        waiting_for_result[i](result);
    }
}

//

API.getCurrentLocation(real_callback);
foreach facility {
    register_callback(function(location){
        ...stuff
    })

当然，由于这是一个重复的PITA，因此有许多Promise库正是这样做的。它们大多也有简洁的方法，允许你使用匿名函数进行非嵌套的“命名回调”模式。

例如，在Dojo中，这可能看起来像

var location_promise = API.GetLocationPromise();
foreach facility {
    location_promise.then(function(location){
        ...use location
    });
}

Answer 4

为什么不定义循环外的当前位置？

var here ;    
API.getCurrentLocation( function( location ) {here = location.coordinates;})

    foreach facility {

        API.getFacilityLocation( function( e ) { // async, takes a callback fxn arg
          var there    = e. coordinates;
          var distance = API.calculateFrom( here, there );
        });
    }

这样你只计算一次

如何避免回调“瀑布”？

4 个答案: