Meteor 流星重型辅助设计模式

所以，meteor每次在模板中调用时都会重新运行帮助程序代码，对吗？我的问题是，我有一个沉重的助手，返回一个大对象。我在这些对象的列表上迭代，然后在一些嵌套对象上迭代，这会导致很大的延迟

那么，是否有任何设计模式可以阻止每次调用整个helper？还是我只需要拆开我的东西

Template.deliveries.helpers({
    current_delivery: function() {
        var delivery_id = Template.instance().data.current_delivery_id;
        var delivery    = Deliveries.findOne({'_id': delivery_id});
        var project     = Projects.findOne({'_id':Session.get('current_project_id')});

        var secondary_profile_names = [];
        if (Session.get('delivery_include_secondaries')) {
            for (var n in project.delivery_profiles) {
                if (project.delivery_profiles[n].name === delivery.delivery_profile) {
                    if (project.delivery_profiles[n].secondary_deliverables) {
                        secondary_profile_names = project.delivery_profiles[n].secondary_deliverables;
                    }
                    break;
                }
            }
        }

        $("#delivery-profile").val(delivery.delivery_profile);

        var elements = $.map(delivery.elements, function(id, idx) {
            i_el = InternalElements.findOne({'_id': id});
            i_el.source_element = SourceElements.findOne({'_id':i_el.source_element});

            if (secondary_profile_names) {
                i_el.secondary_elements = InternalElements.find({
                    'source_element':i_el.source_element._id,
                    'name':{'$in': secondary_profile_names},
                    "$or": [{'is_primary':false}, {'is_primary': {'$exists':false}}]
                },{
                    'sort':{'version':-1},
                    'limit':1
                }).fetch();
            } else {
                i_el.secondary_elements = [];
            }

            return i_el;
        });
        delivery.elements = elements.sort(function(a,b) { return (a.shot_name > b.shot_name) - (a.shot_name < b.shot_name); });

        return delivery;
    },
});

Template.deliveries.helpers({
当前交付：函数（）{
var delivery\u id=Template.instance（）.data.current\u delivery\u id；
var delivery=Deliveries.findOne（{u id'：delivery\u id}）；
var project=Projects.findOne（{''u id'：Session.get（'current'u project'u id'））；
var次要配置文件名称=[]；
if（Session.get（'delivery_include_secondaries'））{
for（项目交付配置文件中的变量n）{
if（project.delivery\u profile[n].name==delivery.delivery\u profile）{
if（项目交付配置文件[n]。次要交付）{
二级\u配置文件\u名称=项目。交付\u配置文件[n]。二级\u交付文件；
}
打破
}
}
}
$（“#交付配置文件”）.val（交付.交付配置文件）；
var-elements=$.map（delivery.elements，函数（id，idx）{
i_el=InternalElements.findOne（{''u id'：id}）；
i_el.source_element=SourceElements.findOne（{''u id'：i_el.source_element}）；
if（辅助配置文件名称）{
i_el.secondary_elements=InternalElements.find({
'source\u element'：i\u el.source\u element.\u id，
'name'：{'$in'：辅助配置文件\名称}，
“$或”：[{'is_primary'：false}，{'is_primary'：{'$exists'：false}]
},{
'sort'：{'version'：-1}，
“限制”：1
}).fetch（）；
}否则{
二次元素=[]；
}
返回i_el；
});
delivery.elements=elements.sort（函数（a，b）{return（a.shot_name>b.shot_name）-（a.shot_name

我成功使用的一种模式是将昂贵计算的结果缓存在本地集合中

---

我喜欢让这个集合中的对象与原始对象的比例为1:1，因此我重复使用原始对象中的

\u id

，以及任何不需要转换的键和值，然后用转换后的值扩展对象。

这真的很复杂，分解所有内容并组织所有内容，在一个助手中太多了想一想如何做得不同如果你只想调用一次，你可以使用

#with

来保存上下文。我不认为这是真的。似乎每次我引用任何helper时，即使在

with

语句中，helper都会重新处理。这准确吗？

MyLocalCache = new Mongo.Collection();