Mvvm 击倒视图模型：为什么自我是全球性的？

我开始为一个搜索引擎编写一个durandal应用程序，其中包含不同的过滤器小部件。我开始按照我在几篇教程中看到的以下标准对viewmodels进行编码（请参见下面的示例，无需进一步说明），但一旦在两个不同ViewModel的“self”上分配了同名函数，我就遇到了问题

我注意到，当我开始复制一个现有的小部件时：在开始时，结果集是混合的，调用函数时没有任何错误……然后依次更改了可观察的和函数的名称，最后我仅通过更改函数名称使其工作。 （例如，self.facets->self.facetsPA等） 我花了一段时间才找到答案，很高兴知道按时完成项目，但这似乎不是一个好的做法，我觉得我可能做错了什么（通过在self对象上分配所有函数？）

谢谢你的解释。干杯，丹尼斯

define(['durandal/http', 'durandal/app', 'durandal/system','durandal/plugins/router'],     function (http, app, system, router) {
var self = this;

var PatentOfficeItem = function(id,name) {
    this.id = ko.observable(id);
    this.name = ko.observable(name);
};

self.facetsPA = ko.observableArray([]);
self.selectablePAFacets =  ko.computed(function() {
    var results = [];
    ko.utils.arrayForEach(self.facetsPA(), function(item) {
        var o = item.key();
        if (!self.officeExists(o))
            results.push(item);

    });
    return results;
});

self.selectedPatentOffices = ko.observableArray([]);
self.officeToAdd = ko.observable("");
self.addPatentOffice = function(item) {
    self.selectedPatentOffices.push(item);
};

self.removePatentOffice = function(item) {
    self.selectedPatentOffices.remove(item);
    var active = router.activeRoute();
    if (active.hash == "#/results/show") {
        app.trigger('PatentSearch:newQuery', 1);
    }
};

self.officeExists = function(code) {
    var result = false;
    ko.utils.arrayForEach(self.selectedPatentOffices(), function(item) {
        if (item.toString()==code.toString())
            result = true;
    });
    return result;
};

self.onCheckFacet = function(f) {
    var key = f.key();
    var value = f.value();
    var checked = f.checked();
    if (!self.officeExists(key))
        self.addPatentOffice(key);
    app.trigger('PatentSearch:newQuery', 1);
};

self.onCheckOffice = function(f) {
    //alert(JSON.stringify(f));
    self.removePatentOffice(f);
    app.trigger('PatentSearch:newQuery', 1);
};

self.getSetDifference2 = function(list1,list2) {
    var difference = [];
    var lookup = {};
    for (var j in list2) {
        var id = list2[j].id;
        lookup[list2[j].id] = list2[j].name;
    }
    for (var i in list1) {
        var id2 = list1[i].id;
        //alert(id);
        //if (lookup[id] == undefined ||lookup[id] === undefined) {
        if (!(id2 in lookup)) {
            difference.push(JSON.stringify(list1[i]));
            //break;
        }
    }
    //alert(JSON.stringify(difference));
    return difference;
};

return {
    activate: function () {},
    viewAttached: function() {
        setTimeout(function() {

            $(".patentFacetMulti").typeahead({
                source: function (query, process) {
                    return $.ajax({
                        url: "/assets/Content/patentoffices.json",
                        type: 'get',
                        data: {},
                        dataType: 'json',
                        success: function (result) {
                            var resultList = result.map(function (item) {
                                var aItem = { id: item.id, name: item.name };
                                return aItem;//JSON.stringify(aItem);
                            });
                            //return process(resultList);
                            return process(self.getSetDifference2(resultList,self.selectedPatentOffices()));
                        }
                    });
                },

                matcher: function (obj) {
                    var item = JSON.parse(obj);
                    return (~item.name.toLowerCase().indexOf(this.query.toLowerCase()) || ~item.id.toLowerCase().indexOf(this.query.toLowerCase()));
                },

                sorter: function (items) {
                    var beginswith = [], caseSensitive = [], caseInsensitive = [], item;
                    while (aItem = items.shift()) {
                        var item = JSON.parse(aItem);
                        if (!item.name.toLowerCase().indexOf(this.query.toLowerCase())) beginswith.push(JSON.stringify(item));
                        else if (~item.name.indexOf(this.query)) caseSensitive.push(JSON.stringify(item));
                        else caseInsensitive.push(JSON.stringify(item));
                    }

                    return beginswith.concat(caseSensitive, caseInsensitive)

                },


                highlighter: function (obj) {
                    var item = JSON.parse(obj);
                    var query = this.query.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, '\\$&')
                    var n = item.name.replace(new RegExp('(' + query + ')', 'ig'), function ($1, match) {
                        return '<strong>' + match + '</strong>'
                    });
                    var m = item.id.replace(new RegExp('(' + query + ')', 'ig'), function ($1, match) {
                        return '<strong>' + match + '</strong>'
                    });
                    return ""+m+"- " + n;
                },

                updater: function (obj) {
                    var item = JSON.parse(obj);
                    //$('#IdControl').attr('value', item.id);
                    self.addOffice(item);

                    var active = router.activeRoute();
                    if (active.hash == "#/results/show") {
                        app.trigger('PatentSearch:newQuery', 1);
                    }


                    //$(this).val("");
                    return "";
                }
            });

        },500);
    },
    selectedPatentOffices:selectedPatentOffices,
    facetsPA:facetsPA
};

define（['durandal/http'、'durandal/app'、'durandal/system'、'durandal/plugins/router'）、函数（http、app、system、router）{
var self=这个；
var patentoficeItem=函数（id、名称）{
this.id=ko.可观察（id）；
this.name=ko.observable（name）；
};
self.facetsPA=ko.observearray（[]）；
self.selectablePAFacets=ko.computed（函数（）{
var结果=[]；
ko.utils.arrayForEach（self.facetsPA（），函数（项）{
var o=item.key（）；
如果（！self.office存在（o））
结果：推送（项目）；
});
返回结果；
});
自行选择的专利文件=ko.observearray（[]）；
self.officeToAdd=ko.可观察（“”）；
self.addPatentOffice=功能（项目）{
自选专利文件推送（项目）；
};
self.removePatentOffice=功能（项目）{
自行选择的专利文件。删除（项目）；
var active=router.activeRoute（）；
if（active.hash==“#/results/show”）{
app.trigger（'PatentSearch:newQuery'，1）；
}
};
self.officeExists=函数（代码）{
var结果=假；
ko.utils.arrayForEach（self.selectedPatentOffices（），函数（项）{
if（item.toString（）==code.toString（））
结果=真；
});
返回结果；
};
self.onCheckFacet=函数（f）{
var key=f.key（）；
var值=f.值（）；
var checked=f.checked（）；
如果（！self.officeExists（key））
self.addpatentofice（键）；
app.trigger（'PatentSearch:newQuery'，1）；
};
self.onCheckOffice=函数（f）{
//警报（JSON.stringify（f））；
自卸除专利权（f）；
app.trigger（'PatentSearch:newQuery'，1）；
};
self.getSetDifference2=函数（列表1、列表2）{
var差=[]；
var查找={}；
for（列表2中的变量j）{
var id=list2[j].id；
查找[list2[j].id]=list2[j].name；
}
for（列表1中的变量i）{
var id2=list1[i].id；
//警报（id）；
//if（查找[id]==未定义| |查找[id]==未定义）{
如果（！（查找中的id2））{
difference.push（JSON.stringify（list1[i]）；
//中断；
}
}
//警报（JSON.stringify（差异））；
收益差；
};
返回{
激活：函数（）{}，
viewAttached:函数（）{
setTimeout（函数（）{
$（“.patentFacetMulti”）.typeahead({
来源：功能（查询、流程）{
返回$.ajax({
url:“/assets/Content/patentofices.json”，
键入：“get”，
数据：{}，
数据类型：“json”，
成功：功能（结果）{
var resultList=result.map（函数（项）{
var aItem={id:item.id，name:item.name}；
返回aItem；//JSON.stringify（aItem）；
});
//返回过程（结果列表）；
返回过程（self.getSetDifference2（结果列表，self.selectedPatentOffices（））；
}
});
},
匹配器：功能（obj）{
var item=JSON.parse（obj）；
return（~item.name.toLowerCase（）.indexOf（this.query.toLowerCase（））| | ~item.id.toLowerCase（）.indexOf（this.query.toLowerCase（））；
},
分拣机：功能（项目）{
变量beginswith=[]，区分大小写=[]，不区分大小写=[]，项；
while（aItem=items.shift（））{
var item=JSON.parse（aItem）；
如果（！item.name.toLowerCase（）.indexOf（this.query.toLowerCase（））开始于.push（JSON.stringify（item））；
else if（~item.name.indexOf（this.query））caseSensitive.push（JSON.stringify（item））；
else不区分大小写。push（JSON.stringify（item））；
}
return beginswith.concat（区分大小写，不区分大小写）
},
荧光灯：功能（obj）{
var item=JSON.parse（obj）；
var query=this.query.replace（/[\-\[\]{}（）*+？，\\\^$\\\s]/g，“\\$&”）
var n=item.name.replace（新的RegExp（'（'+query+'），'ig'），函数（$1，match）{
返回“”+匹配+””
});
var m=item.id.replace（新的RegExp（'（'+query+'），'ig'），函数（$1，匹配）{
返回“”+匹配+””
});
返回“+m+”-“+n”；
},
更新程序：函数（obj）{
var item=JSON.parse（obj）；
//$（'IdControl'）.attr（'value'，item.id）；
自备办公室（项目）；
var active=router.activeRoute（）；
if（active.hash==“#/results/show”）{
应用程序触发（'专利搜索
define(function(require) {
    var widget = require('durandal/widget');

    var ctor = function(element, settings) {
        this.settings = settings;
    };

    ctor.prototype.getHeaderText = function(item) {
        if (this.settings.headerProperty) {
            return item[this.settings.headerProperty];
        }

        return item.toString();
    };

    ctor.prototype.afterRenderItem = function(elements, item) {
        var parts = widget.getParts(elements);
        var $itemContainer = $(parts.itemContainer);

        $itemContainer.hide();

        $(parts.headerContainer).bind('click', function() {
            $itemContainer.toggle('fast');
        });
    };

    return ctor;
});