标签: module-pattern

在做了一些关于模块模式的阅读之后,我已经看到了几种返回你想要公开的属性的方法.

最常见的方法之一是在"return"语句中声明您的公共属性和方法,除了您的私有属性和方法.类似的方式("Revealing"模式)是简​​单地引用您想要公开的属性和方法.最后,我看到的第三种技术是在模块函数中创建一个新对象,在返回所述对象之前为其分配新属性.这是一个有趣的想法,但需要创建一个新对象.

所以我在想,为什么不只是this.propertyName用来分配你的公共属性和方法,最后用到return this最后？这种方式对我来说似乎更简单,因为您可以使用通常var或function语法创建私有属性和方法,或使用this.propertyName语法来声明您的公共方法.

这是我建议的方法:

(function() {

var privateMethod = function () {
    alert('This is a private method.');
}

this.publicMethod = function () {
    alert('This is a public method.');
}

return this;

})();

使用上述方法有任何优点/缺点吗？其他人怎么样？

我正在实现模块模式,并想知道定义和注册事件监听器/处理程序的最佳/首选方式.以下工作,但也许有更好/更简单的方式......

var  MODULE = function() {

    //  private
    var _field1;
    var _field2;

    function  localFunc(p) {
        alert('localFunc');
    }

    //  public
    return {
        // properties
        prop1: _field1,

        // events
        myEvent1Handler: {},
        myEvent1: function() {myEvent1Handler();},
        myEvent2Handler: {},
        myEvent2: function() {myEvent2Handler();},

        addListener: function  (event,func) {
            if (event  ==  "myEvent1")
                myEvent1Handler = func;   

            if (event  ==  "myEvent2")
                myEvent2Handler = func;      
        },

        // public  methods
        method1: function (p) {
            alert('method1 says:' + p);
            MODULE.myEvent1();
        },
        method2: function  (p) {
             alert('method2 doing  stuff');
             localFunc(p);
            MODULE.myEvent2();
        }

    }; …

我已经阅读了有关揭示模块模式的信息,我喜欢它.但是那些"主对象"拥有数十个子对象和数百个函数的大型项目呢？我不想成为将所有代码放在一个匿名函数闭包中的人.

那么大型模块模式项目如何管理？

实现模块模式时,私有函数如何访问模块的私有属性？我还没有看到任何开发人员这样做的例子.有什么理由不去吗？

var module = (function(){
    // private property
    var number = 0;

    // private method
    _privateIncrement = function(){
        // how do I access private properties here?
        number++;
    };

    // public api
    return {
        // OK
        getNumber: function(){
             return number;   
        },
        // OK
        incrNumber: function(){
             number++;  
        },
        // Doesn't work. _privateIncrement doesn't have
        // access to the module's scope.
        privateIncrNumber: function(){
            _privateIncrement();
        }
    };
})();

我想了解JavaScript模块模式.我已经看到它应该是什么样子的例子,但我不明白如何使用它.

例如,这里发生了一些事情:

$('input#share').on("click", function() {

    $('.loading').html('<img class="remove_loading" src="/graphics/loading.gif" />');

    var message = $(".wallmessage").val();

    if (message == ""){
        $("#messageempty").jmNotify();
        $('.remove_loading').remove();
    } else {
        addMessage(message);
    }

    return false;
});


function addMessage(message)
{
    $.ajax({
        url: '/test',
        type: 'POST',
        dataType: "json",
        data: {'message' : message},
        success: function(data) {
                ...
        },
        error: function() {
            ...
        }
    });
}

我如何使用上面的例子:

var myTest = function() {
    var selectId;
    function addMessage () {
        // ...
    }
    return { // public interface
        publicMethod1: function () {
            // all private …

我已经看到在某些项目中,Module Pattern使用而不是Singleton Pattern反之亦然.

我想确切地知道,Module Pattern和之间有什么不同Singleton Pattern？

有没有办法从模块模式中动态访问私有变量的公共函数？test1显示了我对"动态访问"的含义,但使用了公共变量

var x = (function(){
    var x=0, y=2, z=5;

    return {
        toast: 123,
        test1: function(arg){
            return this[arg];
        },
        test2: function(){
            // ??
        }
    };
}());

console.log(x.test1("toast")); // 123
console.log(x.test2("y")); // should return 2

我最终创建了一个存储我的私有变量的私有变量(一个对象),所以我能够像这样访问它们

 privateVarStore[privateVarName]

但是有另一种解决方案吗？

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

(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如何解决这些问题.有人可以解释一下吗？

从单个实例和多实例的角度来看,为什么我会在模块模式之后编写所有那些额外的代码行,而只是使用带有在构造函数体中定义的方法和属性的标准构造函数？

模块模式示例:http://jsfiddle.net/T3ZJE/1/

var module = (function () {
    // private variables and functions
    var foo = 'bar';

    // constructor
    var module = function () {
    };

    // prototype
    module.prototype = {
        constructor: module,
        something: function () {
        }
    };

    // return module
    return module;
})();

var my_module = new module();

console.log(my_module)

构造函数示例:http://jsfiddle.net/EuvaS/2/

function Module(){

    // private variables and functions
    var foo = 'bar';

    //public methods
    this.something = function () {

    }        
}

var my_module …

我倾向于以下列方式编写对象构造函数:

function Person(name) {
    this.name = name;
}
Person.prototype.greet = function () {
    alert("Hello! My name is " + this.name + ".");
};

我注意到一些JavaScript库和框架添加了一些额外的代码,如下所示:

var Person = (function () {
    function Person(name) {
        this.name = name;
    }
    Person.prototype.greet = function () {
        alert("Hello! My name is " + this.name + ".");
    };
    return Person;
})();

我知道自执行匿名函数的作用和用途.我目前未能看到的是,在定义构造函数及其原型时,它提供了哪些优势或好处.

编辑#1:

我知道模块模式及其优点,并且在我的编码中经常使用它.我在沟通中的错误并不清楚我的第一个代码示例不应该在全球范围内.我总是将所有外部JavaScript文件包装在一个自执行的匿名函数中,以强制执行代码的本地范围.

例如:

;(function ( window, undefined ) {
    var p = function (name) {
        this.name;
    };
    p.prototype.greet = function () {
        alert("Hello! My …