//模块化的最初写法
//1.最初写法
//下面的m1和m2就组成了一个模块
//缺点："污染"了全局变量，无法保证不与其他模块发生变量名冲突，而且模块成员之间看不出直接关系。
function m1() {
    //---
}

function m2() {
    //---
}


//2.对象的写法
//可以把模块写成一个对象，所有的模块成员都放到这个对象里面。
var module = new Object({
    _count: 0,

    m1 : function () {
        //---
        alert("函数1！");
    },

    m2 : function () {
        //---
        alert("函数2！");
    }
});

//对象方法模块的使用(开始调用模块里面的成员)
//module.m1();
//module.m2();
//缺点：这样的写法会暴露所有模块成员，内部状态可以被外部改写
//module._count = 5;
//alert(module._count);


//3.立即执行函数的写法
var module1 = (function () {
    var _count1 = 0;

    var m1 = function () {
        //----
    }
    var m2 = function () {
        //----
    }

    return {
        m1 : m1,
        m2 : m2
    }
})();

//使用上面的写法，外部代码无法读取内部的_count变量。
//alert(module1._count1);  //error


//4.放大模式
//给模块module1来添加一个新的方法m3(),然后返回新的module1模块
var module1 = (function (mod) {
    mod.m3 = function () {
        //---
    };

    return mod;
})(module1);


//5.宽放大模式
//＂宽放大模式＂就是"立即执行函数"的参数可以是空对象。
var module1 = (function (mod) {
    //---

    return mod;
})(window.module1 || {});


//6.输入全局变量
//独立性是模块的重要特点，模块内部最好不与程序的其他部分直接交互
//为了在模块内部调用全局变量，必须显式地将其他变量输入模块。
/*var module1 = (function ($, YAHOO) {
    //---
})(JQuery, YAHOO);
*/

//7.模块的规范
//有了模块，我们就可以更方便地使用别人的代码，想要什么功能，就加载什么模块。
//目前，通行的Javascript模块规范共有两种：CommonJS和AMD。

//加载数学模块math.js
//这里的require()用于加载模块
var math = require('math');
//调用模块提供的方法
var result = math.add(1, 2);
alert(result);

//浏览器端的模块，不能采用"同步加载"（synchronous），只能采用"异步加载"（asynchronous）。
//上面的调用模块方式只能在math模块加载完毕之后，才能执行模块中的add方法


//10.AMD（"异步模块定义）
//第一个参数[module]，是一个数组，里面的成员就是要加载的模块；第二个参数callback，则是加载成功之后的回调函数。
//require([module], callback);

//math.add()与math模块加载不是同步的，浏览器不会发生假死。所以很显然，AMD比较适合浏览器环境。
//目前，主要有两个Javascript库实现了AMD规范：require.js和curl.js。
require(['math', function (math) {
    math.add(1, 2);
}]);



//----------------require.js的使用方法--------------------------

//最初的导入.js文件的写法
/*
* 　<script src="1.js"></script>
　　<script src="2.js"></script>
　　<script src="3.js"></script>
　　<script src="4.js"></script>
　　<script src="5.js"></script>
　　<script src="6.js"></script>
*
* 【缺点】
* 1.加载的时候，浏览器会停止网页渲染，加载文件越多，网页失去响应的时间就会越长
* 2.由于js文件之间存在依赖关系，因此必须严格保证加载顺序（比如上例的1.js要在2.js的前面），依赖性最大的模块一定要放到最后加载，当依赖关系很复杂的时候，代码的编写和维护都会变得困难。
*
* 【require.js】解决的问题如下：
* （1）实现js文件的异步加载，避免网页失去响应；
　（2）管理模块之间的依赖性，便于代码的编写和维护。
* */

/**
 * require.js的具体使用方法如下：
 */

//使用require.js来进行模块化开发
//alert("main.js  加载完成！");

/*
* 真正常见的情况是，主模块依赖于其他模块，这时就要使用AMD规范定义的的require()函数。
*　// main.js
　　require(['moduleA', 'moduleB', 'moduleC'], function (moduleA, moduleB, moduleC){
　　　　// some code here
　　});
*
* 第一个参数是一个数组，表示所依赖的模块，上例就是['moduleA', 'moduleB', 'moduleC']，即主模块依赖这三个模块；
* 第二个参数是一个回调函数，当前面指定的模块都加载成功后，它将被调用。
* [注]加载的模块会以参数形式传入该函数，从而在回调函数内部就可以使用这些模块
*
*
* require()异步加载moduleA，moduleB和moduleC，浏览器不会失去响应；
* 它指定的回调函数，只有前面的模块都加载成功后，才会运行，解决了依赖性的问题。
* 假定主模块依赖jquery、underscore和backbone这三个模块，main.js就可以这样写
*　require(['jquery', 'underscore', 'backbone'], function ($, _, Backbone){
　　　　// some code here
　　});
* require.js会先加载jQuery、underscore和backbone，然后再运行回调函数。主模块的代码就写在回调函数中。
* */

//使用AMD规范定义的require()函数
//，require.js假定这三个模块与main.js在同一个目录，文件名分别为jquery.js，underscore.js和backbone.js，
require(['jquery', 'underscore', 'backbone'], function ($, _, Backbone){
    // some code here
});



//模块的加载
//使用require.config()方法，我们可以对模块的加载行为进行自定义
require.config({
    //这里指定了三个模块的文件名字以及文件的路径
    paths : {
        "jquery" : "lib/jquery.min",
        "underscore" : "lib/underscore.min",
        "backbone" : "lib/backbone.min"
    }
});

//也可以改变基目录来实现
require.config({

    //指定基目录
    baseUrl : "js/lib",

    //这里指定了三个模块的文件名字以及文件的路径
    paths : {
        "jquery" : "jquery.min",
        "underscore" : "underscore.min",
        "backbone" : "backbone.min"
    }
});

//也可以使用目标服务器中的地址来加载js文件
//require.js要求， 每一个模块都是一个单独的js 文件
//当模块部署完毕以后，可以用这个require.js提供的工具将多个模块合并在一个文件中，减少HTTP请求数
require.config({
    paths :{
        "jquery": "https://ajax.googleapis.com/ajax/libs/jquery/1.7.2/jquery.min"
    }
});




//加载我自己定义的math.js 下面的模块的方法如下
require(['math'], function (math) {
    alert(math.add(1, 2));          //经过测试，也完美运行了
});

//在这里去调用我的相减的模块
 require(['plus'], function (plus) {
     //这里的意思是指去嗲用plus这个模块下面的result模块
     alert(plus.result(10, 5));     //5
 });


 //加载非规范的模块
//underscore和backbone这两个库，都没有采用AMD规范编写。如果要加载它们的话，必须先定义它们的特征。
require.config({
    //shim属性，专门用来配置不兼容的模块
    shim : {
        'underscore':{
            exports:'_'
        },

        //（1）exports值（输出的变量名），表明这个模块外部调用时的名称；
        //（2）deps数组，表明该模块的依赖性。
        'backbone':{
            deps:['underscore', 'jquery'],
            exports:'Backbone'
        }
    }

});


//来配置一个JQuery插件
require.config({
    shim : {
        'jquery.scroll':{
            //这个模块的依赖项为jquery.js
            deps:['jquery'],

            //这个模块外部调用的名称就使用query.fn.scroll
            exports:'Jquery.fn.scroll'
        }
    }
});


//其他的require.js插件
//domready插件，可以让回调函数在页面DOM结构加载完成后再运行。
require(['domready!', function (doc) {
    //当Dom 元素节点加载完毕之后再运行
}]);



//text和image插件，则是允许require.js加载文本和图片文件。
define([
    'text!review.txt',
    'image!cat,jpg'
],
    function (review, cat) {
        console.log(review);

        //把图片文件加载进来
        document.body.appendChild(cat);
    }
);

//这里我定义了一个数学模块
//5.AMD模板的写法
//模块必须采用特定的define()函数来定义。如果一个模块不依赖其他模块，那么可以直接定义在define()函数之中。

//实例：有一个main.js文件， 定义了一个math模块； math.js的写法如下
/*define(function () {
    var add = function (x, y) {
        return x + y;
    }

    return {
        add: add
    };
});
*/



//如果这个模块还依赖其他模块的写法如下
//当require.js 在加载这个math.js模块的时候， 就会先加载plus.js 文件
define(['plus'], function (plus) {

    var add = function (x, y) {
        alert("plus.js这个依赖项加载完毕!")
        return x + y;
    }

    return {
        add: add
    };
    
});

//我这里又是一个模块
define(function () {
    alert("开始加载plus.js这个依赖项！");
    var minus = function (x, y) {
        return x - y;
    };

    return {
        result : minus
    }
});

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <!--async属性表示这个文件需要异步加载； 避免网页失去响应； IE不支持这个属性，只支持defer，所以把defer也写上-->
    <!--<script type="text/javascript" src="require2.3.5.js" defer async="true"></script>-->
    <!--<script type="text/javascript" src="main.js"></script>-->


    <!--加载require.js以后，下一步就要加载我们自己的代码；两个写在一块的写法如下
    data-main属性的作用是，指定网页程序的主模块; 也就是main.js 文件，
    这个文件会第一个被require.js加载。由于require.js默认的文件后缀名是js，
    所以可以把main.js简写成main。
    -->
    <script src="require2.3.5.js" defer async="true" data-main="main"></script>

</head>
<body>

js 模块化开发测试
</body>
</html>