Node.js 翡翠模板不'；无法获取从express传递的数据

我知道问题的标题几乎相同，但问题不同

我正在使用最新的Keystone.js版本中内置的Jade模板引擎v.1.11.0。在控制器中，我使用两个view.on（'init'）回调查询数据。第一次回调只查询一条记录，并且总是通过。第二种情况有时并不如此

category.js

var keystone = require('keystone');
var async = require('async');
exports = module.exports = function (req, res) {

    var view = new keystone.View(req, res);
    var locals = res.locals;

    // Init locals
    locals.section = 'category';
    locals.filters = {
        category: req.params.category
    };
    locals.data = {
        sections: [],
        category: {}
    };

    // Load current category
    view.on('init', function (next) {

        var q = keystone.list('Category').model.findOne({
            key: locals.filters.category
        });

        q.exec(function (err, result) {
            locals.data.category = result;
            locals.section = locals.data.category.name.toLowerCase(); 
            next(err);
        });
    });


    // Load sections
    view.on('init', function (next) {   
        var q = keystone.list('Section').model.find().where('category').in([locals.data.category]).sort('sortOrder').exec(function(err, results) {

            if (err || !results.length) {
                return next(err);
            }

            async.each(results, function(section, next) {
                keystone.list('Article').model.find().where('section').in([section.id]).sort('sortOrder').exec(function(err, articles){
                    var s = section;
                    if (articles.length) {
                        s.articles = articles;
                        locals.data.sections.push(s);
                    } else {
                        locals.data.sections.push(s);
                    }
                });             

            }, function(err) {
                console.log(locals.data.sections);
            });

            next(err);
        });
    });

    view.render('category');
};

在我看来，我应该始终通过以下步骤：

sections: { _id: 574b909b43ff68163ed86bf2, publicTitle: 'Title 1', key: 'name-1', sortOrder: 3, name: 'Name 1', __v: 0, category: 574b8960947f45f034ac89b4, text: '', image: {} }

category: { _id: 574b8960947f45f034ac89b4, key: 'blabla', sortOrder: 1, name: 'Blabla', __v: 0, image: {} }

但60%的时候，我都会这样：

sections:

category: { _id: 574b8960947f45f034ac89b4, key: 'johndoe', sortOrder: 1, name: 'JohnDoe', __v: 0, image: {} }

奇怪的是，如果我转到另一个类别，它有更多的部分，像30篇文章，我90%的时间得到部分，但仍然缺少10%。这种情况在开发和生产中都存在

---

某些“下一步”（）发射是否太早？我看不出我哪里搞砸了。

好吧。在阅读了

async

之后，我设法使用

async.parallel

使它正常工作

var keystone = require('keystone');
var async = require('async');
exports = module.exports = function (req, res) {

    var view = new keystone.View(req, res);
    var locals = res.locals;

    // Init locals
    locals.section = 'category';
    locals.filters = {
        category: req.params.category
    };
    locals.data = {
        sections: [],
        category: {}
    };

    // Load current category
    view.on('init', function (next) {

        var q = keystone.list('Category').model.findOne({
            key: locals.filters.category
        });

        q.exec(function (err, result) {
            locals.data.category = result;
            locals.section = locals.data.category.name.toLowerCase();
            getChildrenRecords(locals.data.category, next);
        });
    });


    function getChildrenRecords(category, next){

        var q = keystone.list('Section').model.find().where('category').in([category]).sort('sortOrder').exec(function(err, results) {

            if (err || !results.length) {
                return next(err);
            }

            callItems = [];

            for(var i = 0; i < results.length; i++) {
                var data = results[i];
                callItems.push(makeCallbackFunction(data));
            }

            function makeCallbackFunction(section) {
                return function (callback) {

                    keystone.list('Article').model.find().where('section').in([section.id]).sort('sortOrder').exec(function(err, articles){

                        if (err) return callback(err);

                        if (articles.length) { section.articles = articles; }
                            locals.data.sections.push(section);
                            callback();
                    });
                };
            }

            async.parallel(callItems, function(err, results){
                next(err);
            });
        });
    }


    // Render the view
    view.render('category');
};

var keystone=require（'keystone'）；
var async=require（'async'）；
导出=模块。导出=功能（req，res）{
var view=新的keystone.view（请求、恢复）；
var局部变量=res.局部变量；
//初始局部变量
locals.section='category'；
locals.filters={
类别：req.params.category
};
本地数据={
章节：[]，
类别：{}
};
//负载电流类别
view.on（'init'，函数（下一个）{
var q=keystone.list（'Category'）.model.findOne({
关键字：locals.filters.category
});
q、 exec（函数（错误、结果）{
locals.data.category=结果；
locals.section=locals.data.category.name.toLowerCase（）；
getChildrenRecords（locals.data.category，next）；
});
});
函数getChildrenRecords（类别，下一个）{
var q=keystone.list（'Section'）.model.find（）.where（'category'）.in（[category]）.sort（'sortOrder'）.exec（函数（err，results）{
if（err | |！results.length）{
返回下一个（错误）；
}
callItems=[]；
对于（var i=0；i

好的。在阅读了

async

之后，我设法使用

async.parallel

使它正常工作

var keystone = require('keystone');
var async = require('async');
exports = module.exports = function (req, res) {

    var view = new keystone.View(req, res);
    var locals = res.locals;

    // Init locals
    locals.section = 'category';
    locals.filters = {
        category: req.params.category
    };
    locals.data = {
        sections: [],
        category: {}
    };

    // Load current category
    view.on('init', function (next) {

        var q = keystone.list('Category').model.findOne({
            key: locals.filters.category
        });

        q.exec(function (err, result) {
            locals.data.category = result;
            locals.section = locals.data.category.name.toLowerCase();
            getChildrenRecords(locals.data.category, next);
        });
    });


    function getChildrenRecords(category, next){

        var q = keystone.list('Section').model.find().where('category').in([category]).sort('sortOrder').exec(function(err, results) {

            if (err || !results.length) {
                return next(err);
            }

            callItems = [];

            for(var i = 0; i < results.length; i++) {
                var data = results[i];
                callItems.push(makeCallbackFunction(data));
            }

            function makeCallbackFunction(section) {
                return function (callback) {

                    keystone.list('Article').model.find().where('section').in([section.id]).sort('sortOrder').exec(function(err, articles){

                        if (err) return callback(err);

                        if (articles.length) { section.articles = articles; }
                            locals.data.sections.push(section);
                            callback();
                    });
                };
            }

            async.parallel(callItems, function(err, results){
                next(err);
            });
        });
    }


    // Render the view
    view.render('category');
};

var keystone=require（'keystone'）；
var async=require（'async'）；
导出=模块。导出=功能（req，res）{
var view=新的keystone.view（请求、恢复）；
var局部变量=res.局部变量；
//初始局部变量
locals.section='category'；
locals.filters={
类别：req.params.category
};
本地数据={
章节：[]，
类别：{}
};
//负载电流类别
view.on（'init'，函数（下一个）{
var q=keystone.list（'Category'）.model.findOne({
关键字：locals.filters.category
});
q、 exec（函数（错误、结果）{
locals.data.category=结果；
locals.section=locals.data.category.name.toLowerCase（）；
getChildrenRecords（locals.data.category，next）；
});
});
函数getChildrenRecords（类别，下一个）{
var q=keystone.list（'Section'）.model.find（）.where（'category'）.in（[category]）.sort（'sortOrder'）.exec（函数（err，results）{
if（err | |！results.length）{
返回下一个（错误）；
}
callItems=[]；
对于（var i=0；i

尝试在1 init中嵌套查询。我从一开始就尝试过，因为某些原因，如果我这样做，页面将永远无法加载。另外，拥有两个init似乎也不是问题，这种方法在keystone中被广泛使用，甚至在样板文件中也是如此；在异步回调中，它也会导致永久加载。请尝试将查询嵌套在1 init中。我从一开始就尝试过，由于某种原因，如果我这样做，页面将永远加载。另外，拥有两个init似乎也不是问题，这种方法在keystone中被广泛使用，甚至在样板文件中也是如此；在异步回调中，它也会导致永久加载。