异步递归在Node.js中是什么意思

Question

In Mongoose documentation for validation they say " Validation is asynchronously recursive: when you call Model#save, sub-document validation is executed. If an error happens, your Model#save callback receives it "

What do they mean by it? Suppose I have 5 validations than will they be run in parallel or series? Or is they get called in series with a callback that is received by the model save method? Please help me understand this? I know its a very easy question But I could not get any help from searching and all. So please.

Answer 1

It means that, despite the fact that you have multiple events triggering "simultaneously" each method maintains it's own state, and it's own error handling steps separately for each request and for each step.

Consider this example in which we need disk information to initialize a database query. Each successive step is an asynchronous operation, that calls a callback.

function dataBaseQuerys(someQuerys) {
    function queryDatabase(someQuery) {

        if(someQuery === undefined) return;

        fs.readFile('someFile', function (err, data) {
            'use strict';

            var myQuery = someQuery + data;

            query(myQuery, function (err, qData) {
                doSomethingWithTheQuery(qData);
                queryDatabase(someQuerys.pop());//Recursion(behaves iteratively, but with async calls!  No for loop necessary)
            });
        });
    }

    queryDatabase(someQuerys.pop());
}

Now consider the following example in which we don't take advantage of async recursion.

function dataBaseQuerys(someQuerys) {

    for(var i = 0; i < someQuerys.size; i++) {
        var fileData = fs.readFileSync('someFile');

        var myQuery = someQuerys[i] + fileData;

        doSomethingWithTheQuery(querySync(myQuery));//Finding a DB module that does a "querySync" is probably not possible, but assume it is.
    }
}

These two examples do the same thing. The iterative one is a little more difficult to get the error handling correct, and try/catch in javascript is bad because it disallows optimization. The recursive one, the syntax is a little tricky with getting the closure data for the "nextQuery" object and such, but it doesn't clog the event loop, which is priceless for performance. All the developers are telling you is that they used the first example.

EDIT: I'm gonna hand hold a little bit here and answer your bullet points as they pertain to these examples:

What do they mean by it? Honestly can't get more specific here... my example explicitly outlines the idiom they are using.

Suppose I have 5 validations than will they be run in parallel or series? -They will run in series, asynchronously. This is the point of the "recursion". Each point in code is guaranteed to run in order, but other things can happen in the background, just not things involving any of the callback sequences the queries are implementing.

Or is they get called in series with a callback that is received by the model save method? -YES

Please help me understand this? - If this does not help, you need to ask a more specific question. Also, if you don't see how the logic I laid out in my examples covers all of these questions, you should spend a little more time wrapping your head around async "event based callbacks". If you're accustomed to C-style logic flow it can be hard to wrap your head around, I've been there and wish someone at the time would have told me the same.