module-pattern.md

#模块模式

Module Pattern

##知识点一：模块模式有下列4种方法：

1. Object字面量模式
2. Module模式
3. AMD模式
4. CommonJS模式
5. ECMAScript Harmony模式

###Object字面量模式

var myObjectLiteral = {
 
    variableKey: variableValue,
 
    functionKey: function () {
      // ...
    }
};

####特点 优点： 1. 简单容易，不使用new，不用实例化 缺点： 1. 没有作用域概念，只能挂载到全局引用 1. 所有属性都可以访问，没有私有属性/方法 适用： 1. 简单设置

###Module模式

最简单的Module模式定义与实现

var testModule = (function () {
 
  var counter = 0;
 
  return {
 
    incrementCounter: function () {
      return counter++;
    },
 
    resetCounter: function () {
      console.log( "counter value prior to reset: " + counter );
      counter = 0;
    }
  };
 
})();
 
// Usage:
 
// Increment our counter
testModule.incrementCounter();
 
// Check the counter value and reset
// Outputs: counter value prior to reset: 1
testModule.resetCounter();

####特点 优点： 1. 私有变量完全与全局作用域实现隔离，只能通过内部方法访问（在模块的闭包内） 1. 公共函数往往已声明，在debug过程中更容易查看哪些函数发生异常

####Module模式变化 混入模式 下面演示如何引入一个第三方库（JQuery、underscore），并且取一个本地别名（可以有效防止命名冲突）

// Global module
var myModule = (function ( jQ, _ ) {
 
    function privateMethod1(){
        jQ(".container").html("test");
    }
 
    function privateMethod2(){
      console.log( _.min([10, 5, 100, 2, 1000]) );
    }
 
    return{
        publicMethod: function(){
            privateMethod1();
        }
    };
 
// Pull in jQuery and Underscore
})( jQuery, _ );
 
myModule.publicMethod();

####Module模式变化 引出模式 下面演示如何新建一个全局变量，不需要在本模块使用它，并引出到模块外，并支持上面的例子

// Global module
var myModule = (function () {
 
  // Module object
  var module = {},
    privateVariable = "Hello World";
 
  function privateMethod() {
    // ...
  }
 
  module.publicProperty = "Foobar";
  module.publicMethod = function () {
    console.log( privateVariable );
  };
 
  return module;
 
})();

####特点 优点： 1. 比object字面量模式更清晰 1. 支持作用域，可以有私有数据 缺点： 1. 访问公有成员和私有成员的方法是不同的，一旦需要改变他们的可见性时候，需要改变每一个曾经使用过该成员的地方 1. 很难访问那些之后在方法里添加的私有成员（？） 1. 无法为私有成员创建自动化单元测试（因为私有方法不暴露） 1. 无法轻易扩展私有方法（？私有方法一改，其他关联的公有方法全部都要改）

####Module模式变化（揭示模块）

var myRevealingModule = (function () {
 
        var privateCounter = 0;
 
        function privateFunction() {
            privateCounter++;
        }
 
        function publicFunction() {
            publicIncrement();
        }
 
        function publicIncrement() {
            privateFunction();
        }
 
        function publicGetCount(){
          return privateCounter;
        }
 
        // 暴露的公有指针指向到私有函数和属性上
 
       return {
            start: publicFunction,
            increment: publicIncrement,
            count: publicGetCount
        };
 
    })();
 
myRevealingModule.start();

####特点 优点： 1. 该模式可以使语法一致，很容易看出哪些可以公开访问，改善可读性 缺点： 1. 如果私有函数引用一个公有函数，如果需要扩展（继承）公有函数，此公有函数不能被覆盖。因为私有函数要继续引用原有的公有函数，所以此模式只适用于一般函数使用，不能用于任何继承(或尝试覆盖其方法)。引用了私有变量的公有成员遵守无补丁原则

缺点例子：

var revealed = (function() {      
  function foo() {
    return baz();
  }

  function bar() {
    return "I am the original bar!";
  }

  // private function always calls bar because it's in the closure
  // and it can't see the "instance" variable
  function baz() {
    return bar();
  }

  return { foo : foo, bar : bar }
})();

var child = Object.create(revealed);

child.bar = function() {
  return "I am the new bar!";
}

// we want this to call the new bar but it doesn't
console.log(child.foo()); // I am the original bar!