Javascript 如何处理这些异步函数（设计模式？）

我有一个应用程序需要执行一些引导/启动，如：

• 阿贾克斯
• 动态需求
• 路由，设置其他东西

在你能跑之前

我现在很难把这些任务组织在一起。 特别是异步行为让我头疼。 目前，我正在使用事件来共享获取的结果并观察应用程序的状态。不幸的是，这导致了基因组学上的，不方便的废话。 然后我尝试使用一些承诺库，比如q、jquery.deleted，但它们与我的问题并不匹配

这是代码的简化版本：

// this could be an ajax call fetching some user data
var fetchUser = function() {
    var user = {};
    // lets emulate the ajax call with setTimeout
    setTimeout(function() {
        // set some values
        user.username = 'bodo';
        user.password = 'helloKitty';
        // return the user object we "fetched"
        return user;
    }, 300);
};

// this could fetch some config or some requirejs modules
var fetchConfig = function() {
    var config = {};
    // we emulate this too...
    setTimeout(function() {
        return config;
    }, 200);
};

// this could be anything else like setting up some objects
var justSetUpSomething = function() {
    var someObj = {};
    someObj.router = 'this could be a router object for example';
    someObj.logger = 'or a logger';
    return someObj;
};

// in the final step everything should be merged together
// and be passed as event argument
var finalStep = function(user, config, someObj) {
    var mainObj = {};
    mainObj.user = user;
    mainObj.config = config;
    mainObj.someObj = someObj;
    // trigger some event system
    trigger('everything:ready', mainObj);
};​

也可在以下网址查看：

我希望这能描述我的问题：

有三个完全不同的异步任务。当它们都准备好时，它们的结果必须合并并以某种方式传递给另一个对象。

事件让这一切变得可行，但远不是可以理解的，承诺也不能真正让我快乐难道没有其他有用的设计模式吗？

听起来，只要解决了依赖关系，您的大多数功能实际上都是同步的（即

config

和

someObj

不做任何异步操作，它们可能只是异步加载。如果您使用require.js，您是否尝试过使用

define

从代码的角度简单地使用其功能使

require

调用同步？那么您只需担心必须是异步的调用（

fetchUser

）

---

首先，由于已经有了requirejs，您可以使用它来加载三个模块。requirejs异步并行地解析依赖项，并在加载时调用最终的工厂函数

但是，每个延迟库也提供了合并承诺的函数：当所有单个承诺都被解决时，合并的承诺将被解决；如果其中一个被拒绝，则合并的承诺将被拒绝。相应的函数为和：

---

@Bergi我认为它们只能帮助对抗“末日金字塔”？而且你正在建立一个对库的硬依赖。但是你有没有一个例子？我也使用requirejs依赖数组作为定义参数。只是你必须知道你想知道什么。如果你不知道或者想动态地保存东西，那么你需要加载它们uelly async。如果你对一个模块有双向依赖关系也是一样的。你能给我一个jQuery的例子吗。当延迟对象不是ajax函数（例如自定义函数）时？你还有什么异步的东西吗？比如动态requirejs加载。但是我注意到你可以将函数包装成$.Deferred（）如果只是使用amd模块，我建议只使用requirejs处理，正如@SeanVieira建议的那样

// In app/main.js perhaps?
define(["data/user",
            "app/config",
            "app/someObject",
            "app/events"], 
    function(user, config, someObj, eventBus) {
        // By the sound of it config and someObj are ready once loaded
        var mainObj = {"config": config, "someObj": someObj};
        eventBus.register_once("data:user:loaded", function(user) {
            mainObj.user = user; 
            eventBus.trigger("everything:ready", mainObj);
        });
        user.fetchUser()
});

// in data/user.js
define(["app/config", "app/events", "vendor/jquery"],
    function(config, eventBus, $) {
        function user_loaded(user) {
            eventBus.trigger("data:user:loaded", user);
        }
        function fetchUser() {
            $.get(config.dataendpoint + "/user/1", user_loaded);
        }
    return {"fetchUser": fetchUser};
});

function fetchX() {
    var d = new $.Deferred();
    asynchronousThing(function callback(x) {
        d.resolve(x);
    });
    return d.promise();
}
$.when(fetchX(), fetchY(), …).then(function finalStep(x, y, …) {
    // merge everything together
    return new Event();
}).done(function readyCallback(e) {
    // this is effectively your 'everything:ready' "event"
});