//模块化的最初写法
//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>
