JS模块化编程由来

1. 原始写法

  • 模块就是实现特定功能的一组方法。
  • 只要把不同的函数(以及记录状态的变量)简单地放在一起,就算是一个模块。
  • 缺点:"污染"了全局变量,无法保证不与其他模块发生变量名冲突,而且模块成员之间看不出直接关系。
 function m1(){
    //...
  }

  function m2(){
    //...
  }

M1和m2组成一个模块,直接调用即可

2. 对象写法

  • 可以把模块写成一个对象,所有的模块成员都放到这个对象里面
  • 暴露所有模块成员,内部状态可以被外部改写。比如,外部代码可以直接改变内部计数器的值。(没有达到封闭效果)
 var module1 = new Object({

    _count : 0,//可以直接对这个取值,暴露

    m1 : function (){
      //...
    },

    m2 : function (){
      //...
    }

  });

3. 立即执行函数IIFE,(Immediately-Invoked Function Expression,IIFE)

  • 可以达到不暴露私有成员目的
  • 这就是基本的模块写法!!
 var module1 = (function(){

    var _count = 0;

    var m1 = function(){
      //...
    };

    var m2 = function(){
      //...
    };

    return { //只暴露了这些成员,无法读取_count
      m1 : m1,
      m2 : m2
    };

  })();

4.可对IIFE方法进行加工(放大模式augmentation)

  • 一个模块很大,必须分成几个部分,或者一个模块需要继承另一个模块,
//为module1模块添加了一个新方法m3(),然后返回新的module1模块。
  var module1 = (function (mod){

    mod.m3 = function () {
      //...
    };

    return mod;

  })(module1);

5. 宽放大模式(Loose augmentation)

  • 在浏览器环境中,模块的各个部分通常都是从网上获取的,有时无法知道哪个部分会先加载。如果只采用augmentation,第一个执行的部分有可能加载一个不存在空对象,这时就要采用"宽放大模式"。 ```js   var module1 = ( function (mod){

    //...

    return mod;

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

与"放大模式"相比,"宽放大模式"就是"立即执行函数"的参数可以是空对象

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

    //...

  })(jQuery, YAHOO);

上面的module1模块需要使用jQuery库和YUI库,就把这两个库(其实是两个模块)当作参数输入module1。这样做除了保证模块的独立性,还使得模块之间的依赖关系变得明显。

EG:

jQuery源码中:

(function( window, undefined ) {
// jquery code
})(window);

——通过定义一个匿名函数,创建了一个“私有”的命名空间,该命名空间的变量和方法,不会破坏全局的命名空间。这点非常有用也是一个JS框架必须支持的功能,jQuery被应用在成千上万的JavaScript程序中,必须确保jQuery创建的变量不能和导入他的程序所使用的变量发生冲突。

参考:

  1. 《JavaScript Module Pattern: In-Depth》http://www.adequatelygood.com/JavaScript-Module-Pattern-In-Depth.html
  2. http://www.ruanyifeng.com/blog/2012/10/javascript_module.html

AMD CMD UMD CommonJs

CommonJs用在服务器端,AMD和CMD用在浏览器环境 AMD 提前执行(异步加载:依赖先执行)+延迟执行(RequireJS) CMD 延迟执行(运行到需加载,根据顺序执行)( SeaJS)

AMD模块

1. 说明

  • AMD是"Asynchronous Module Definition"的缩写,意思就是"异步模块定义"。由于不是JavaScript原生支持,使用AMD规范进行页面开发需要用到对应的库函数,也就是大名鼎鼎RequireJS,
  • 它采用异步方式加载模块,模块的加载不影响它后面语句的运行。所有依赖这个模块的语句,都定义在一个回调函数中,等到加载完成之后,这个回调函数才会运行。
  • 主要解决两个问题:
    1. 多个js文件可能有依赖关系,被依赖的文件需要早于依赖它的文件加载到浏览器
    2. js加载的时候浏览器会停止页面渲染,加载文件越多,页面失去响应时间越长

2. 使用方式

加载:

require([module], callback);

require([increment'], function (increment) {
    increment.add(1);
});

定义: RequireJS定义了一个函数 define,它是全局变量,用来定义模块: define(id?, dependencies?, factory);

define("alpha", ["require", "exports", "beta"], function (require, exports, beta) {
      exports.verb = function() {
          return beta.verb();
          //Or:
          return require("beta").verb();
      }
  });

参数说明:

  • id:指定义中模块的名字,可选;如果没有提供该参数,模块的名字应该默认为模块加载器请求的指定脚本的名字。如果提供了该参数,模块名必须是“顶级”的和绝对的(不允许相对名字)。
  • 依赖dependencies:是一个当前模块依赖的,已被模块定义的模块标识的数组字面量。 依赖参数是可选的,如果忽略此参数,它应该默认为["require", "exports", "module"]。然而,如果工厂方法的长度属性小于3,加载器会选择以函数的长度属性指定的参数个数调用工厂方法。
  • 工厂方法factory,模块初始化要执行的函数或对象。如果为函数,它应该只被执行一次。如果是对象,此对象应该为模块的输出值。

CMD模块

1. 说明

  • CMD 即Common Module Definition通用模块定义,CMD规范是国内发展出来的,
  • 就像AMD有个requireJS,CMD有个浏览器的实现SeaJS,
  • SeaJS要解决的问题和requireJS一样,只不过在模块定义方式和模块加载(可以说运行、解析)时机上有所不同。

2. 使用方式

加载 amd一样

定义

define(function(require, exports, module) {

  // 模块代码

});

3. AMD CMD对比

  • AMD是依赖关系前置,在定义模块的时候就要声明其依赖的模c块
  • CMD是按需加载依赖就近,只有在用到某个模块的时候再去require
// CMD
define(function(require, exports, module) {
  var a = require('./a')
  a.doSomething()
  // 此处略去 100 行
  var b = require('./b') // 依赖可以就近书写
  b.doSomething()
  // ... 
})

// AMD 默认推荐的是
define(['./a', './b'], function(a, b) { // 依赖必须一开始就写好
  a.doSomething()
  // 此处略去 100 行
  b.doSomething()
  ...
})

参考: https://www.jianshu.com/p/d67bc79976e6

UMD模块

  • 既然CommonJs和AMD风格一样流行,似乎缺少一个统一的规范。所以人们产生了这样的需求,希望有支持两种风格的“通用”模式,于是通用模块规范(UMD)诞生了。
  • 这个模式略难看,但是它兼容了AMD和CommonJS,同时还支持老式的“全局”变量规范:
(function (root, factory) {
    if (typeof define === 'function' && define.amd) {
        // AMD
        define(['jquery'], factory);
    } else if (typeof exports === 'object') {
        // Node, CommonJS之类的
        module.exports = factory(require('jquery'));
    } else {
        // 浏览器全局变量(root 即 window)
        root.returnExports = factory(root.jQuery);
    }
}(this, function ($) {
    //    方法
    function myFunc(){};

    //    暴露公共方法
    return myFunc;
}));

CommonJs 模块

  • js的一个提供一包的模块规范,目前主要用在nodejs和npm的包上

定义:一个文件即是一个模块,通过module.exports或者exports进行模块导出

/********util.js************/
//导出一个模块对象,这个对象有getUrl方法
exports.getUrl =  ()=>{
}

//module.exports = ()=>{} 可以用这种方式将对象导出为方法

加载: 默认require取到的是对象

const util = require(./util'); // util.js的模块对象
util.getUrl();

模块运行:

//node每次加载会加载模块,new一个模块对象
function Module(id,parent){
    this.id = id;
    this.exports = {}
    //...
}

//然后对js模块文件util.js进行包装,然后利用Module对象传进去进行生成
(function(exports require,module, __filename,__dirname){
    exports.getUrl = ()=>{};
})

results matching ""

    No results matching ""