javascript 模块化模式总结（二）

一、对象字面值

这种设计模式中，一个对象被描述为一组以逗号分隔的名称/值对括在大括号（{}）的集合。对象内部的名称可以是字符串或是标记符后跟着一个冒号":"。在对象里最后一个名称/值对不应该以","为结束符，因为这样会导致错误。

例如：var myModel = {

	myProperty : "someValue",
	//对象字面值包含了属性和方法，例如我们可以定义一个模块配置进对象里边
	myConfig:{
		useCache : true,
		language : "en"
	},
	//非常基本的方法
	myMethod : function(){
		console.log(" this is myMethod");
	},
	//输出基于当前的配置
	myMethod1 :function(){
		console.log("Cache is:"+ (this.myConfig.useCache)? "enabled" : "disabled" );
	},
	//重写当前的配置
	myMethod2 : function(newConfig){
		if(typeof newConfig == "object"){
			this.myConfig = newConfig;
                      consle.log(this.myConfig.language);

		}	
	}
}

1、myModel.myMethod();

输出：this is myMethod 

2、myModel.myMethod1();

输出：Cache is:enabled

3、myModel.myMethod2({ language: "zh", useCache : false });

 输出： zh

　　

二、使用自包含的模块实现了模块模式

这种模式的特点：

• 可以创建只能被我们模块访问的私有函数。这些函数没有暴露出来（只有一些API是暴露出来的），它们被认为是完全私有的。
• 当我们在一个调试器中，需要发现哪个函数抛出异常的时候，可以很容易的看到调用栈，因为这些函数是正常声明的并且是命名的函数。
• 这种模式同样可以让我们在不同的情况下返回不同的函数。

例如：

var basketModel = ( function(){
    var basket = [];
    function dosomethingPrivate()
    {
    }
    function dosomethingElsePrivate()
    {
    }
    // Return an object exposed to the public
    return{
        // Add items to our basket
        addItem : funtion(values){
            basket.push(values);
        },
        // Get the count of items in the basket
        getItemCount : function(){
            return basket.length;
        },
        dosomething : dosomethingPrivate,
        getTotal : function(){
            var q = this.getItemCount();
            p = 0;
            while(q--){
                p += this.basket[q].price;
            }
            return p;
        }
    };
}());

    使用方法：
    basketModule.addItem({  item: "bread",  price: 0.5});
    basketModule.addItem({  item: "butter",  price: 0.3});
    //Outputs: 2
    console.log( basketModule.getItemCount() );
    //Outputs: 0.8
    console.log( basketModule.getTotal() );
    //undefined
    console.log( basketModule.basket ); 
    //undefined
    console.log( basket );

三、Import mixins(导入混合)

这个变体展示了如何将全局（例如 jQuery）作为一个参数传入模块的匿名函数。
这种方式允许我们导入全局，并且按照我们的想法在本地为这些全局起一个别名。

var myModel = (function(JQ,_){
    function privateMethod1(){
        jQ(".container").html("test");
    }
    function privateMethod2(){
        console.log( _.min([10, 5, 100, 2, 1000]) );
    }
    return {
        publicMethod : function(){
            privateMethod1();
        }
    }

}(JQ,_));

四、暴露式模块模式 

当我们想要在一个公有方法中调用另外一个公有方法，或者访问公有变量的时候，我们不得不重复主对象的名称。他也不喜欢模块模式中，当想要将某个成员变成公共成员时，修改文字标记的做法。因此在这个模式中，我们可以简单地在私有域中定义我们所有的函数和变量，并且返回一个匿名对象，这个对象包含有一些指针，这些指针指向我们想要暴露出来的私有成员，使这些私有成员公有化。

var myRevealingModule = function () { 
        var privateCounter = 0; 
        function privateFunction() {
		privateCounter++;        
		}         
		function publicFunction() {
		publicIncrement();        
		}         
		function publicIncrement() {
		privateFunction();        
		}         
		function publicGetCount(){ 
		return privateCounter;        
		}         
		// Reveal public pointers to         
		// private functions and properties                
		return { 
		start: publicFunction, 
		increment: publicIncrement,
		count: publicGetCount 
		};
}(); 

myRevealingModule.start();