JavaScript Module Pattern

　　Module Pattern是JavaScript里面最常见的编码模式。

　　匿名闭包是这个模式可以实现的前提，例如下面的代码：

    (function()
    {
        function dosomething()
        {
            console.log("dosomething");
        }
    })()

　　上面的（function（）｛｝）返回的是一个函数引用，在后面再加（）变成这样：（function（）｛｝）（）表示执行这个函数，所以这样写是可以的，我还以为我以前出错了呢。这是因为我发现这样写也行： 

    (function ()
    {
        function dosomething()
        {
            console.log("dosomething");
        }
    }());

　　用括号把这个匿名函数表达式括起来，如果不括起来，会认为这是一个函数定义，所以提示没有函数名出错。

下面我来进入正题：

　　1，全局导入。通过传入参数，可以避免一些难以管理的代码问题：传入window输出window的高。

    (function(w)
    {
        function dosomething()
        {
            console.log(w.screen.height);
        }
        dosomething();
    })(window);

 

　　2，模块的导出。可以让我们在匿名函数里面定义的方法可以给外面的空间使用：

    var moduleA = (function(w)
    {
        var _name = "Hello world";
        function getName()
        {
            console.log("you can do something before get name");
            return _name;
        }
        function setName(name)
        {
            console.log("you can do something before set name");
            _name = name;
        }
        function privateDosomething()
        {
            console.log(getName() + " " + w.screen.height);
        }
        return {
            publicDosomething:privateDosomething,
            setName:setName,
            getName:getName
        }
    })(window);
    moduleA.publicDosomething();
    moduleA.setName("Jobs");
    console.log(moduleA.getName());
//    you can do something before get name 
//    Hello world 1080 
//    you can do something before set name 
//    you can do something before get name 
//    Jobs

　　3，这样还不够，这样一个module只可以在一个js文件中，要想能够在不同的module里面使用，需要首先使用导入module，然后为module添加属性，然后把module导出：

现在一个module.js的文件里面写下面的代码（假设这是CoderA写的代码）：

var moduleA = (function (m)
{
    m.dosomething2= function()
    {
        console.log("Hey , this is dosomething2!");
    }
    return m;
})(moduleA||{});
//<script src="Module.js"></script> 记得include进主文件

CoderB想用到CoderA写的Module，但是他也想自己加一些属性进去，首先他需要include CoderA的module.js :<script src="Module.js"></script>. 然后他开始敲自己的代码：

        var moduleA = (function(module,w)
        {
            var _name = "Hello world";
            function getName()
            {
                console.log("you can do something before get name");
                return _name;
            }
            function setName(name)
            {
                console.log("you can do something before set name");
                _name = name;
            }
            function privateDosomething()
            {
                console.log(getName() + " " + w.screen.height);
            }

            module.setName = setName;
            module.getName = getName;
            module.publicDosomething = privateDosomething;

            return module;
        })(moduleA||{},window);
    moduleA.publicDosomething();
    moduleA.setName("Jobs");
    console.log(moduleA.getName());
    moduleA.dosomething2(); //这个是CoderA写的代码
//    you can do something before get name 
//    Hello world 1080 
//    you can do something before set name 
//    you can do something before get name 
//    Jobs 
//    Hey , this is dosomething2!

我们看到， 如果这里，CoderB也写了一个dosomething2属性，这样会覆盖掉A的，我还没想到有什么好的方法。或许可以用一个oldMethiod的变量存起来。