Javascript 带有while循环的Nodejs异步_Javascript_Node.js_Asynchronous_Synchronous

Javascript 带有while循环的Nodejs异步

javascript node.js asynchronous

Javascript 带有while循环的Nodejs异步,javascript,node.js,asynchronous,synchronous,Javascript,Node.js,Asynchronous,Synchronous,所以我有这个代码： Rating.find({user: b}, function(err,rating) { var covariance=0; var standardU=0; var standardV=0; while (rating.length>0){ console.log("the avarage rating u is:" + avarageR

所以我有这个代码：

Rating.find({user: b}, function(err,rating) {
            var covariance=0;
            var standardU=0;
            var standardV=0;

            while (rating.length>0){
                console.log("the avarage rating u is:" + avarageRatingU)
                console.log("the avarage rating v is:" + avarageRatingV)
                currentMovie = rating.pop();
                var u=currentMovie.value-avarageRatingU;
                standardU = standardU + Math.pow(u,2);
                var v=0;
                Rating.find({movieid:currentMovie.movieid, user:a}, function(err,ratings) {
                    if (err) throw err;
                    if(ratings.length>0){
                        v=ratings.pop().value-avarageRatingV;
                        standardV=standardV+Math.pow(v,2);
                        covariance =covariance+u*v;
                        console.log(covariance);

                    }
                })
            }
            console.log(covariance)
            callback(null,covariance);
            //sim = covariance/(Math.sqrt(standardU)*Math.sqrt(standardV));
        })

问题是当我打印协方差时，它将打印0，因为打印发生在计算之前。我考虑过使用async.series，但是，我不能在while循环中使用回调函数

任何提示都将不胜感激

泰：）

这个怎么样：

Rating.find({user: b}, function(err,rating) {
        var covariance=0;
        var standardU=0;
        var standardV=0;

        var c = rating.length; // loop counter
        var r = 0; // received counter
        function aux_callback (covariance) {
            r++;
            if (r==c)
                callback(null,covariance);
        }

        while (rating.length>0){
            console.log("the avarage rating u is:" + avarageRatingU)
            console.log("the avarage rating v is:" + avarageRatingV)
            currentMovie = rating.pop();
            var u=currentMovie.value-avarageRatingU;
            standardU = standardU + Math.pow(u,2);
            var v=0;
            Rating.find({movieid:currentMovie.movieid, user:a}, function(err,ratings) {
                if (err) throw err;
                if(ratings.length>0){
                    v=ratings.pop().value-avarageRatingV;
                    standardV=standardV+Math.pow(v,2);
                    covariance =covariance+u*v;
                    console.log(covariance);
                    aux_callback(covariance);
                }
            })
        }
        //sim = covariance/(Math.sqrt(standardU)*Math.sqrt(standardV));
    })

您需要从循环中的lambda函数触发回调，以确保在运行该代码之前不会发生回调。考虑到您似乎需要完成所有循环，我创建了两个计数器，

来跟踪lambda必须运行的次数，

来计算您调用aux\u回调的次数。此代码应该等到您计算完所有协方差后再调用

回调
如何：
Rating.find({user: b}, function(err,rating) {
        var covariance=0;
        var standardU=0;
        var standardV=0;

        var c = rating.length; // loop counter
        var r = 0; // received counter
        function aux_callback (covariance) {
            r++;
            if (r==c)
                callback(null,covariance);
        }

        while (rating.length>0){
            console.log("the avarage rating u is:" + avarageRatingU)
            console.log("the avarage rating v is:" + avarageRatingV)
            currentMovie = rating.pop();
            var u=currentMovie.value-avarageRatingU;
            standardU = standardU + Math.pow(u,2);
            var v=0;
            Rating.find({movieid:currentMovie.movieid, user:a}, function(err,ratings) {
                if (err) throw err;
                if(ratings.length>0){
                    v=ratings.pop().value-avarageRatingV;
                    standardV=standardV+Math.pow(v,2);
                    covariance =covariance+u*v;
                    console.log(covariance);
                    aux_callback(covariance);
                }
            })
        }
        //sim = covariance/(Math.sqrt(standardU)*Math.sqrt(standardV));
    })

您需要从循环中的lambda函数触发回调，以确保在运行该代码之前不会发生回调。考虑到您似乎需要完成所有循环，我创建了两个计数器，c
来跟踪lambda必须运行的次数，r
来计算您调用aux\u回调的次数。此代码应该等到您计算完所有协方差后再调用回调
如何：
Rating.find({user: b}, function(err,rating) {
        var covariance=0;
        var standardU=0;
        var standardV=0;

        var c = rating.length; // loop counter
        var r = 0; // received counter
        function aux_callback (covariance) {
            r++;
            if (r==c)
                callback(null,covariance);
        }

        while (rating.length>0){
            console.log("the avarage rating u is:" + avarageRatingU)
            console.log("the avarage rating v is:" + avarageRatingV)
            currentMovie = rating.pop();
            var u=currentMovie.value-avarageRatingU;
            standardU = standardU + Math.pow(u,2);
            var v=0;
            Rating.find({movieid:currentMovie.movieid, user:a}, function(err,ratings) {
                if (err) throw err;
                if(ratings.length>0){
                    v=ratings.pop().value-avarageRatingV;
                    standardV=standardV+Math.pow(v,2);
                    covariance =covariance+u*v;
                    console.log(covariance);
                    aux_callback(covariance);
                }
            })
        }
        //sim = covariance/(Math.sqrt(standardU)*Math.sqrt(standardV));
    })

您需要从循环中的lambda函数触发回调，以确保在运行该代码之前不会发生回调。考虑到您似乎需要完成所有循环，我创建了两个计数器，c
来跟踪lambda必须运行的次数，r
来计算您调用aux\u回调的次数。此代码应该等到您计算完所有协方差后再调用回调
如何：
Rating.find({user: b}, function(err,rating) {
        var covariance=0;
        var standardU=0;
        var standardV=0;

        var c = rating.length; // loop counter
        var r = 0; // received counter
        function aux_callback (covariance) {
            r++;
            if (r==c)
                callback(null,covariance);
        }

        while (rating.length>0){
            console.log("the avarage rating u is:" + avarageRatingU)
            console.log("the avarage rating v is:" + avarageRatingV)
            currentMovie = rating.pop();
            var u=currentMovie.value-avarageRatingU;
            standardU = standardU + Math.pow(u,2);
            var v=0;
            Rating.find({movieid:currentMovie.movieid, user:a}, function(err,ratings) {
                if (err) throw err;
                if(ratings.length>0){
                    v=ratings.pop().value-avarageRatingV;
                    standardV=standardV+Math.pow(v,2);
                    covariance =covariance+u*v;
                    console.log(covariance);
                    aux_callback(covariance);
                }
            })
        }
        //sim = covariance/(Math.sqrt(standardU)*Math.sqrt(standardV));
    })

您需要从循环中的lambda函数触发回调，以确保在运行该代码之前不会发生回调。考虑到您似乎需要完成所有循环，我创建了两个计数器，c
来跟踪lambda必须运行的次数，r
来计算您调用aux\u回调的次数。这段代码应该等到您计算完所有协方差后再调用callback
这是我今晚的第二个解决方案：）。所以，让我试试：
    //supposing you are using node js
    var Q = require('q'); //https://github.com/dscape/nano
    Rating.find({user: b}, function(err,rating) {
                var covariance=0;
                var standardU=0;
                var standardV=0;
                var promises = [];
                while (rating.length>0){
                    console.log("the avarage rating u is:" + avarageRatingU)
                    console.log("the avarage rating v is:" + avarageRatingV)
                    currentMovie = rating.pop();
                    var u=currentMovie.value-avarageRatingU;
                    standardU = standardU + Math.pow(u,2);
                    var v=0;
                    var def = Q.defer();
                    promises.push(def);
                    Rating.find({movieid:currentMovie.movieid, user:a}, function(err,ratings) {
                        if (err) {
                            def.reject();
                            throw err;
                        }
                        if(ratings.length>0){
                            v=ratings.pop().value-avarageRatingV;
                            standardV=standardV+Math.pow(v,2);
                            covariance =covariance+u*v;
                            def.resolve();
                            //console.log(covariance);
                        }

                    });

                }
                Q.allSettled(promises, function() {
                    console.log(covariance);    
                });          
                callback(null,covariance);
                //sim = covariance/(Math.sqrt(standardU)*Math.sqrt(standardV));
            });

这是我今晚的第二个解决方案：）。所以，让我试试：
    //supposing you are using node js
    var Q = require('q'); //https://github.com/dscape/nano
    Rating.find({user: b}, function(err,rating) {
                var covariance=0;
                var standardU=0;
                var standardV=0;
                var promises = [];
                while (rating.length>0){
                    console.log("the avarage rating u is:" + avarageRatingU)
                    console.log("the avarage rating v is:" + avarageRatingV)
                    currentMovie = rating.pop();
                    var u=currentMovie.value-avarageRatingU;
                    standardU = standardU + Math.pow(u,2);
                    var v=0;
                    var def = Q.defer();
                    promises.push(def);
                    Rating.find({movieid:currentMovie.movieid, user:a}, function(err,ratings) {
                        if (err) {
                            def.reject();
                            throw err;
                        }
                        if(ratings.length>0){
                            v=ratings.pop().value-avarageRatingV;
                            standardV=standardV+Math.pow(v,2);
                            covariance =covariance+u*v;
                            def.resolve();
                            //console.log(covariance);
                        }

                    });

                }
                Q.allSettled(promises, function() {
                    console.log(covariance);    
                });          
                callback(null,covariance);
                //sim = covariance/(Math.sqrt(standardU)*Math.sqrt(standardV));
            });

这是我今晚的第二个解决方案：）。所以，让我试试：
    //supposing you are using node js
    var Q = require('q'); //https://github.com/dscape/nano
    Rating.find({user: b}, function(err,rating) {
                var covariance=0;
                var standardU=0;
                var standardV=0;
                var promises = [];
                while (rating.length>0){
                    console.log("the avarage rating u is:" + avarageRatingU)
                    console.log("the avarage rating v is:" + avarageRatingV)
                    currentMovie = rating.pop();
                    var u=currentMovie.value-avarageRatingU;
                    standardU = standardU + Math.pow(u,2);
                    var v=0;
                    var def = Q.defer();
                    promises.push(def);
                    Rating.find({movieid:currentMovie.movieid, user:a}, function(err,ratings) {
                        if (err) {
                            def.reject();
                            throw err;
                        }
                        if(ratings.length>0){
                            v=ratings.pop().value-avarageRatingV;
                            standardV=standardV+Math.pow(v,2);
                            covariance =covariance+u*v;
                            def.resolve();
                            //console.log(covariance);
                        }

                    });

                }
                Q.allSettled(promises, function() {
                    console.log(covariance);    
                });          
                callback(null,covariance);
                //sim = covariance/(Math.sqrt(standardU)*Math.sqrt(standardV));
            });

这是我今晚的第二个解决方案：）。所以，让我试试：
    //supposing you are using node js
    var Q = require('q'); //https://github.com/dscape/nano
    Rating.find({user: b}, function(err,rating) {
                var covariance=0;
                var standardU=0;
                var standardV=0;
                var promises = [];
                while (rating.length>0){
                    console.log("the avarage rating u is:" + avarageRatingU)
                    console.log("the avarage rating v is:" + avarageRatingV)
                    currentMovie = rating.pop();
                    var u=currentMovie.value-avarageRatingU;
                    standardU = standardU + Math.pow(u,2);
                    var v=0;
                    var def = Q.defer();
                    promises.push(def);
                    Rating.find({movieid:currentMovie.movieid, user:a}, function(err,ratings) {
                        if (err) {
                            def.reject();
                            throw err;
                        }
                        if(ratings.length>0){
                            v=ratings.pop().value-avarageRatingV;
                            standardV=standardV+Math.pow(v,2);
                            covariance =covariance+u*v;
                            def.resolve();
                            //console.log(covariance);
                        }

                    });

                }
                Q.allSettled(promises, function() {
                    console.log(covariance);    
                });          
                callback(null,covariance);
                //sim = covariance/(Math.sqrt(standardU)*Math.sqrt(standardV));
            });

试着用承诺！现在Node.js 4.x已经发布，所有JavaScript ES6（和承诺）都将随之发布。您可以查看Mozilla基金会文档中的承诺。
如果您以前从未使用过承诺，那么它真正做的就是允许您在值可用之前返回值。之后，承诺能够以实际价值得到解决或拒绝
在这种情况下，您需要封装内部评级。在新承诺（函数（resolve，reject）{…}）中调用find（）
，并在承诺上附加一个then（）
子句，该子句打印出协方差的值。当您从内部的Rating.find（）
函数中检索实际协方差时，只需使用resolve参数（这是一个接受单个值的函数）并传递协方差，这样它就会传递到承诺的then（）
子句中的函数中，该子句将打印协方差
如果有任何困惑，请给我留言
 尝试使用承诺！现在Node.js 4.x已经发布，所有JavaScript ES6（和承诺）都将随之发布。您可以查看Mozilla基金会文档中的承诺。
如果您以前从未使用过承诺，那么它真正做的就是允许您在值可用之前返回值。之后，承诺能够以实际价值得到解决或拒绝
在这种情况下，您需要封装内部评级。在新承诺（函数（resolve，reject）{…}）中调用find（）
，并在承诺上附加一个then（）
子句，该子句打印出协方差的值。当您从内部的Rating.find（）
函数中检索实际协方差时，只需使用resolve参数（这是一个接受单个值的函数）并传递协方差，这样它就会传递到承诺的then（）
子句中的函数中，该子句将打印协方差
如果有任何困惑，请给我留言
 尝试使用承诺！现在Node.js 4.x已经发布，所有JavaScript ES6（和承诺）都将随之发布。您可以查看Mozilla基金会文档中的承诺。
如果您以前从未使用过承诺，那么它真正做的就是允许您在值可用之前返回值。之后，承诺能够以实际价值得到解决或拒绝
在这种情况下，您需要封装内部评级。在新承诺（函数（resolve，reject）{…}）中调用find（）
，并在承诺上附加一个then（）
子句，该子句打印出协方差的值。当您从内部的Rating.find（）
函数中检索实际协方差时，只需使用resolve参数（这是一个接受单个值的函数）并传递协方差，这样它就会传递到承诺的then（）
子句中的函数中，该子句将打印协方差
如果有任何困惑，请给我留言
 尝试使用承诺！现在Node.js 4.x已经发布，所有JavaScript ES6（和承诺）都将随之发布。您可以查看Mozilla基金会文档中的承诺。
如果你以前从未使用过承诺，它真正做的就是
covariance = covariance + u * v;

while (rating.length>0){
    currentMovie = rating.pop();
    var u=currentMovie.value-avarageRatingU;
    var v=0;
    Rating.find({movieid:currentMovie.movieid, user:a}, function(err,ratings) {
        if (err) throw err;
        if(ratings.length>0){
            v=ratings.pop().value-avarageRatingV;
            standardV=standardV+Math.pow(v,2);
            covariance =covariance+u*v;
...

Rating.find({user: b}, function(err,rating) {
    var covariance = 0;
    var standardU = 0;
    var standardV = 0;
    var u = 0;

    while (rating.length > 0){
        console.log("the avarage rating u is:" + avarageRatingU)
        console.log("the avarage rating v is:" + avarageRatingV)
        currentMovie = rating.pop();
        u = currentMovie.value - avarageRatingU;
        standardU = standardU + Math.pow(u, 2);
        (function(u) {
            Rating.find({ movieid: currentMovie.movieid, user: a }, function(err, ratings) {
                if (err) throw err;
                if (ratings.length > 0) {
                    var v = ratings.pop().value - avarageRatingV;
                    standardV = standardV + Math.pow(v,2);
                    covariance = covariance + u * v;
                    console.log(covariance);

                }
            });
        })(u);
    }
    console.log(covariance)
    callback(null,covariance);
    //sim = covariance/(Math.sqrt(standardU)*Math.sqrt(standardV));
});