1

我想加载一个主题，它的 25 个评论和每个评论最多 5 个子评论，在每个评论/子评论上递归重复，直到找到所有相关评论。

我目前正在使用角度指令递归订阅并添加到本地集合，只要评论有孩子。它工作得很好，但是在加载最初的 25 条评论和加载他们的孩子，然后是他们的孩子等等之间有一些滞后（可以预料）。

当一次只加载一个页面时，这个问题不是问题。当使用无限滚动并增加最初的 25 条评论限制时，这会成为一个问题。当子评论消失并再次加载后重新出现时，它将导致页面上下跳跃。

我想知道如何在发送给本地客户之前递归查找所有评论，这样我就不需要为每个主题进行多次往返。

我在ck-gaming.com上加载了一个演示

如果滚动到底部，它会加载更多，并且随着子评论重新加载到页面中，您会看到它跳跃。

我能想到的两个选项是在加载页面之前使用解析来等待所有集合，或者使用递归发布来首先获取所有集合。

想法？想法？

好的，我的第一次尝试，如果可能的话，我想要一些想法。

对于发布，我决定使用publish-composite以使同一集合的发布更容易。

对于我写的出版物：

Meteor.publishComposite('oneDiscussion', function (slug, options) {

var query = {};
query.find = function () {
    return Discussions.find({ slug: slug }, { limit: 1 });
};

var mainChildQuery = Comments.find({ slug: slug }, { limit: 1 });

query.children = [];
query.children[0] = {};
query.children[0].find = function (discussion) {
    return mainChildQuery;
};
query.children[0].children = [];
query.children[0].children[0] = {};
query.children[0].children[0].find = function (comment) {
    return Meteor.users.find({ _id: comment.author.id }, { limit: 1, fields: { profile: 1, roles: 1, createdAt: 1, username: 1 } });
};
query.children[0].children[1] = {};
query.children[0].children[1].find = function (parent) {
    Counts.publish(this, 'numberOfComments', Comments.find(
        { parent_id: parent._id }
        ), { noReady: true });
    console.log(options)
    return Comments.find({ parent_id: parent._id }, options);
};

//  var parentQuery = Comments.find({ slug: slug });
var parent = mainChildQuery.fetch();
var children = Comments.find({ parent_id: parent[0]._id }, { limit: 25 }).fetch();

var childrenIds = _.pluck(children, '_id');


var getChildren = function (children_ids, thisParent) {

    var i = 0;
    thisParent.children = [];

    var recursive = function getEm(children, parent) {
        _.each(children, function (id) {

            //              parent.children[i] = new Children(id);
            var query = Comments.find({ parent_id: id }, { limit: 5, sort: { date: -1 } });
            parent.children[i] = {
                find: function () {
                    return Comments.find({ parent_id: id }, { limit: 5, sort: { date: -1 } });
                }
            };


            var children1 = query.fetch();
            var newChildrenIds = _.pluck(children1, '_id');
            i++;
            if (newChildrenIds.length > 0) {
                getEm(newChildrenIds, parent);
            }
        });
    }

    recursive(children_ids, thisParent);

};

getChildren(childrenIds, query.children[0].children[1]);
return query;

});

到目前为止似乎工作正常，虽然在我的桌面上运行它并没有我想象的那么好。我会部署它，看看在线是否有区别。我回家后会更新，并且可以更新实时站点。如果有人能发现我写的东西有问题，将不胜感激。

4

1 回答 1

0

我想出了我认为最好的解决方案。我改进了上面的功能，到目前为止我真的很喜欢结果。

这是发布功能：

Meteor.publishComposite('comments', function (item_id, options) {
    /**
     * TODO: Add query to find a user for each comment.
     */
    /**
     * Start building our query.
     * Add the latest 25 (depending on options) child comments of the viewed item
     * to the query.
     */
    var query = {
        find: function () {
            return Comments.find({ parent_id: item_id }, options);
        }
    };
    // Query the database for the first 25? comments, we'll need their _id's
    var mainChildren = Comments.find({ parent_id: item_id }, options).fetch();
    // pluck the id's from the initial comments
    var mainChildrenIds = _.pluck(mainChildren, '_id');

    /**
     * Builds the remaining query based on the id's plucked from the children
     *  above.
     * @param childrens_id The id's we just plucked from the above query
     * @param thisParent This is the parent query
     */
    var getChildren = function (children_ids, parentQuery) {
        // initiate i to 0
        var i = 0;
        // add a child array to the current parent query.
        parentQuery.children = [];
        var recursive = function getem(children, parent) {
            _.each(children, function (id) {
                var query = Comments.find({ parent_id: id }, { limit: 5, sort: { date: 1 } });
                parent.children[i] = {
                    find: function () {
                        return query;
                    }
                };
                var children1 = query.fetch();
                var newChildrenIds = _.pluck(children1, '_id');
                i++;
                if (newChildrenIds.length > 0) {
                    getem(newChildrenIds, parent);
                }
            });
        };
        // recursively build the query if there are children found.
        recursive(children_ids, parentQuery);
    };
    // initiate the query build function
    getChildren(mainChildrenIds, query);
    return query;
});

我创建了一个示例应用程序，您可以在此处在 GitHub 上获取

你可以在这里查看它在流星垫上运行

它能做什么

该函数所做的只是构建 publishComposite 查询，只要有子 id，就递归循环遍历子 id。当没有更多的孩子时，它就会停止。

使用它

您想要一组具有 parent_id 字段的评论（或任何您正在嵌套的内容）。此字段将填充父帖子 ID、父项目 ID（如果说创建带有评论/评论的商店）。父帖子 ID 当然是您正在评论的评论或帖子。有关详细信息，请参阅示例。

于 2015-08-12T21:29:10.603 回答