标签: revealing-module-pattern

我最近在阅读" 学习JavaScript设计模式 "一书.我没有得到的是模块模式和揭示模块模式之间的区别.我觉得他们是一回事.有谁可以举个例子？

我正在学习JavaScript,并且遇到了以下结构:

var Test = (function () {

  function func1() {
      //do something.....
  }

  function func2() {
      //do something.....
  }

  function func3() {
      //do something.....
  }

  return {
      func1: func1,
      func2: func2,
      func3: func3
  };

})();

我想知道返回块正在做什么.这是一个非常常用的JavaScript结构吗？请告诉我在哪里可以获得更多相关信息.

我目前正在重构一些我们拥有的Javascript代码,除此之外我还改变了它以利用揭示模块模式.代码看起来更整洁,它工作正常但我在大纲视图中看不到这些功能.我将顶级命名空间var视为var,但您无法展开它以查看其中的函数.

让我们说代码看起来像这样:

function myFunc1() {}
function myFunc2() {}

在这种情况下,您可以在大纲视图中看到这两个函数.但是如果你改成它:

var myNamespace = function()
{
  function myFunc1() {}
  function myFunc2() {}

  return {
    name: "myNamespace",
    myFunc1: myFunc1,
    myFunc2: myFunc2
  }
}();

然后大纲视图只显示myNamespace var.我试过看但却找不到能够正确显示层次结构的视图.有没有人知道一种方法来查看这个或者是eclipse不能这样做的情况？

我想使用Knockout.js为我的REST服务构建一个客户端.我有很多Repositorys我想通过不同的网址访问 - 所以我想出了使用Revealing-Prototype-Pattern的解决方案.我的问题:我无法找到如何使用我从服务中收到的"数据"映射ItemsProperty.

var Repository = function (url) {
    this.Url = url;
    this.Items = ko.observableArray([]);
    this.PendingItems = ko.observableArray([]);
};

Repository.prototype = function () {
    var  
        getAllItems = function () {
            var self = this;
            $.getJSON(self.Url, function (data) {
            // data=[{"Id":1,"Name":"Thomas","LastName":"Deutsch"},{"Id":2,"Name":"Julia","LastName":"Baumeistör"}]
                ko.mapping.fromJS(data, self.Items);
            });
        }, 
    ...


// i call it like this:
customerRepository = new Repository('http://localhost:9200/Customer');
customerRepository.getAllItems();

我认为问题在于:ko.mapping.fromJS(data,self.Items); 但我找不到合适的方法.
问题:我做错了什么？我找到了一个例子 - 他们也在做同样的想法:http: //jsfiddle.net/jearles/CGh9b/

我在确定实现这一目标的最佳方法时遇到了一些麻烦.

我想要一个带有构造函数的模块,该构造函数接受一个存储它的参数,以便以后在模块中使用.

var ModuleB = function(moduleA) {
    this.moduleA = moduleA;
}

ModuleB.prototype = function() {
    //private stuff/functions
    function someMethod() {
        moduleA.doSomething();
    }

    //public api
    return {
        someMethod : someMethod
    };
}();

在其他一些文件中

//ModuleA defined elsewhere
var moduleA = new ModuleA();

//...

var module = new ModuleB(moduleA);
module.someMethod();

现在上面someMethod,moduleA未定义,并且this是全局窗口对象.有人可以解释我如何访问moduleA吗？我不明白this.moduleA = moduleA;构造函数后会发生什么.我不是一个真正的javascript开发人员,所以如果我在这里或其他地方使用错误的模式,请随意加入.

我以为我开始很好地理解JavaScript,但显然不是.让我用一个例子来解释我的问题.首先,我定义了以下模块:

var Test = function() {
    var counter = 0;

    function init() {
        alert(counter);
    }

    return {
        counter: counter,
        init: init
    }
};

然后我创建了2个实例:

var test1 = new Test();
var test2 = new Test();

现在我更新计数器变量(因为它是公共的)并做一些警报.到现在为止还挺好.

alert(test1.counter); // Alerts 0
test1.counter = 5;
alert(test2.counter); // Alerts 0
test2.counter = 10;
alert(test1.counter); // Alerts 5

现在终于说出以下内容:

test1.init(); // Alerts 0
test2.init(); // Alerts 0

这是我不明白的一点.为什么这个警报0？我认为第一个警报是5,第二个是10.

如果有人能解释上述内容如何起作用或指出我正确的方向,我将不胜感激.谢谢

我最近熟悉了Revealing Module模式,并且我已经阅读了很多关于它的文章.

这似乎是一个非常好的模式,我想在我拥有的一个大项目中开始使用它.在我正在使用的项目中:Jquery,KO,requirejs,Jquery Mobile,JayData.在我看来它似乎非常适合KO ViewModels.

具体来说我想使用它的THIS版本.

我找不到的一件事是使用这种模式的缺点,是因为没有(我觉得很难相信)？

在开始使用它之前我应该​​考虑什么？

我正在尝试实现Revealing Module Pattern,但我无法公开修改后的私有属性.

var myRevealingModule = (function(){

    var name = 'Diogo';

    function setName () {
       name = name + ' Cardoso';
    }

    return {
        fullName: name,
        set: setName
    };

}());

// Sample usage:
myRevealingModule.set();
console.log(myRevealingModule.fullName); // "Diogo" instead of the excepted "Diogo Cardoso".

对于模块模式,我做的事情如下:

(function(namespace) {
    // tons of code
    // blabla
})(window.myGlobalNamespace);

如何拆分代码？我可以想到几种方法,比如使用命名空间的层次结构,或者扩展外部的对象window.myGlobalNamespace.additionalFunc = function () {//blabla}.还有什么其他方法？优缺点都有什么？哪一个被认为是更好的做法？

这两个答案都提出了RequireJS.能否解释一下RequireJS如何解决这些问题:

first.js:

(function(context) {
    var parentPrivate = 'parentPrivate';
})(window.myGlobalNamespace);

second.js:

(function(context) {
    this.childFunction = console.log('trying to access parent private field: ' + parentPriavte);
}(window.myGlobalNamespace.subNamspace);

main.js:

window.myGlobalNamespace.subNamspace.childFunction(); // doesn't work

人们可以做到

window.myGlobalNamespace.subNamspace.childFunction = function() {alert("a new function");}

改变我的代码的行为!

这里有两个问题:

1. 我们不能拥有儿童可以访问的字段,但不能访问外部公众(即受保护的).有没有办法实现这一目标？

2. 如果没有,意味着如果我们想要访问,我们需要将其公之于众.然后用户将能够修改它!

更重要的是,所有公共功能都可以更改和替换.我不希望这种情况发生.

我不知道RequireJS如何解决这些问题.有人可以解释一下吗？

这种模式的缺点是,如果私有函数引用公共函数,则如果需要补丁,则不能覆盖该公共函数.这是因为私有函数将继续引用私有实现,并且该模式不适用于公共成员,仅适用于函数.

有没有人举例说明他的意思？

链接到上面引用的Revealing Module Pattern