JavaScript（异步）如何确定在继续之前要“等待”什么？

Question

我最近经常使用 JavaScript，我试图弄清楚解释器如何确定何时“等待”，以及何时异步转到下一行代码。

以这两个代码示例为例。阅读我的 cmets，了解我的困惑。

1：

function doAThing(thing, callback) {

    var someBoolean;

    if ( !thing ) {
        someBoolean = true;
    } else {
        someBoolean = false;
    }

    // Calling the callback function only happens *after* the above if statement,
    // meaning the interpreter waits instead of just calling it immediately?
    callback(someBoolean);
}

2：

function doOtherThing(thing, callback) {
    var someBoolean;

    // Some fake ORM, querying a fake DB with a where clause of thing
    Model.find().where({ someProperty: thing }).exec(function(err, results){

        if ( results ) {
            someBoolean = true;
        } else {
            someBoolean = false;
        }

    });

    // Calling the callback function happens *immediately* and does NOT wait for
    // someBoolean to get a value inside the ORM query above before it proceeds,
    // so the callback function is given an undefined value for someBoolean 
    callback(someBoolean);

}

• 在示例 1 中，为什么/如何在调用回调函数之前等待 if 语句完全执行？
• 您如何确定 JavaScript 将“等待”的内容与不等待的内容？
• 在不使用 Q、Async 等库的情况下，有哪些策略可以在原生 javascript 中更优雅地处理此控制流？

我可能有一些术语错误，请随时纠正我。我在这里尝试理解它并感谢任何建议。我也有兴趣阅读与 JavaScript 异步相关的任何资源，但不知道去哪里找。

干杯！

编辑：我知道在示例 #2 中，我可以通过将回调调用放在 ORM 查询的末尾来“强制”仅在 someBoolean 具有值时调用回调。但是，这通常很容易变得笨拙。这是示例＃3：

function doSomething(thing, callback) {
    // Some fake ORM, querying a fake DB with a where clause of thing
    Model.find().where({ someProperty: thing }).exec(function(err, results){
        ModelTwo.find().where({ somethingElse: thing }).exec(function(err, results){
            ModelThree.find().where({ somethingElse: thing }).exec(function(err, results){
                ModelFour.find().where({ somethingElse: thing }).exec(function(err, results) {
                    // Tons and tons of nesting, getting ever-more-confusing
                    // and pushing my code further to the right....
                    callback();
                });
            });
        });
    });
}

这是一个非常复杂的例子，但在使用 Node.js 之前我遇到过这样的情况。当我必须在数据库上运行多个查询或多次与某些外部服务交互时，它会很快变得非常混乱，最后我需要调用回调......

我想我的问题是：在原生 javascript 中，有没有更好的方法来避免所有这些嵌套的废话，或者我应该只使用像 Q 或 Async 这样的 Promise 库？

我想要一个更像这样的控制流，在原生 JS 中：

function doAThing(thing, callback) {
    var bool1, bool2, bool3, bool4;

    SomeLib.someAction().exec(function(err, results){
        bool1 = false;
    });

    SomeLib.someOtherAction().exec(function(err, results){
        bool2 = true;
    });

    SomeOtherLib.action().exec(function(err, results){
        bool3 = false;
    });

    SomeOtherLib.delete().exec(function(err, results){
        bool4 = true;
    });

    // I'd like this only to be called when the above 4 actions are complete,
    // **without** nesting all of the actions together and calling the
    // callback at the end of the last one. As far as I understand it now...
    // I will need a library like async or q in order to have a
    // control flow like this?
    callback(bool1, bool2, bool3, bool4);
}

Answer 1

呃，JavaScript 是完全同步的。您的代码示例都没有代表解释器就是否等待做出任何“决定”； 没有等待。两个示例中的每个语句都将按顺序执行而不会被中断。有些函数会阻塞，有些不会，但这不取决于解释器。

if ( !thing ) {
   someBoolean = true;
} else {
    someBoolean = false;
}


// Calling the callback function only happens *after* the above if statement,
// meaning the interpreter waits instead of just calling it immediately?
callback(someBoolean);

如果函数阻塞，它会阻塞。您不必担心，您的代码只是按照从上到下的执行顺序进行。

var someBoolean;

// Some fake ORM, querying a fake DB with a where clause of thing
Model.find().where({ someProperty: thing }).exec(function(err, results){

    if ( results ) {
        someBoolean = true;
    } else {
        someBoolean = false;
    }
});

// Calling the callback function happens *immediately* and does NOT wait for
// someBoolean to get a value inside the ORM query above before it proceeds,
// so the callback function is given an undefined value for someBoolean 
callback(someBoolean);

没错。您应该在传递给 ORM 的函数中调用 callback。当结果准备好时，您需要调用回调，这就是回调的重点。你的函数不需要立即调用它的回调，那样会破坏目的。

您如何确定 JavaScript 将“等待”的内容与不等待的内容？

通过阅读文档。如果它接受一个回调函数，这可能就是它将值传递给您的代码的方式。

在不使用 Q、Async 等库的情况下，有哪些策略可以在原生 javascript 中更优雅地处理此控制流？

...你什么意思？你传给它一个回调函数。如果你想变得比这更复杂，你应该使用一个库，比如 Q、Async 等。

Answer 2

了解事件是如何工作的，因为 js 中的所有异步操作都涉及事件和事件监听器。它与仅将回调作为参数传递然后在函数内部调用它们无关。

异步代码的工作方式如下：

• 一个函数注册一个事件监听器和一个事件处理程序，然后它完成并返回
• 当它侦听的事件触发时，事件处理程序会转到在单个线程中执行的代码列表的末尾，按照它们发生的顺序一个接一个地执行。

想象一下，您作为单线程、一行执行运行的所有代码。您在该代码中注册的任何事件侦听器都会在您的初始化代码中的所有其他内容完成后执行，它无法在两者之间执行，就像两个事件无法同时处理一样。

您的所有示例所做的只是将线程引导到几个角落，将其集中在一个函数周围，也许会打一个结，但它们并没有真正“脱离”该线程。另一方面，如果您只使用

setTimeout(yourCallback,0);

然后你突然异步了。您的回调将进入等待行的末尾，并且必须等到当前代码的每个部分都被执行并且“没有其他事情要做”，因此它可以进入下一个排队等待或空闲，等待触发事件。