前端模块化

一、什么是模块？

将一个复杂的程序依据一定的规则(规范)封装成几个块(文件), 并进行在一起。
块的内部数据与实现是私有的, 只是向外部暴露一些接口(方法)与外部其它模块通信。

二、模块化开发的好处

避免变量污染，命名冲突
提高代码复用率
提高了可维护性
方便依赖关系管理，更好的分离, 并且按需加载

三、模块化的演化

1、全局function模式

编码: 将不同的功能封装成不同的全局函数
缺点: 污染全局命名空间, 容易引起命名冲突或数据不安全，而且模块成员之间看不出直接关系

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

2、namespace模式 : 简单对象封装

优势: 减少了全局变量，解决命名冲突
缺点: 数据不安全(外部可以直接修改模块内部的数据)，会暴露所有模块成员，内部状态可以被外部改写。

let myModule = {
  data: 'www.baidu.com',
  foo() {
    console.log(`foo() ${this.data}`)
  },
  bar() {
    console.log(`bar() ${this.data}`)
  }
}
myModule.data = 'other data' //能直接修改模块内部的数据
myModule.foo() // foo() other data

3、IIFE模式：匿名函数自调用(闭包)

编码: 将数据和行为封装到一个函数内部, 通过给window添加属性来向外暴露接口
优点: 数据是私有的, 外部只能通过暴露的方法操作
缺点: 如果当前这个模块依赖另一个模块怎么办?

　　比如如下的模块代码：

(function(window) {
    let data = 'www.baidu.com';
    //操作数据的函数
    function foo() {
        //用于暴露公有函数
        console.log(`我是函数foo(),data为:${data}`)
    }
    function bar() {
        //用于暴露公有函数
        console.log(`我是函数bar(),data为:${data}`);
        otherFun() //内部调用
    }
    function otherFun() {
        //内部私有的函数
        console.log('我是函数otherFun()')
    }
    //暴露行为
    window.myModule = { foo, bar } //ES6写法
})(window);

　　调用方法如下代码所示：

<script type="text/javascript" src="module.js"></script>
<script type="text/javascript">
    myModule.foo();
    myModule.bar();
    console.log(myModule.data);//undefined 不能访问模块内部数据
    myModule.data = 'xxxx';//不是修改的模块内部的data
    myModule.foo() //没有改变
</script>

　　结果如下所示：

4、IIFE模式增强 : 引入依赖

　　比如引入jQuery

　　比如如下的模块代码：　　

(function(window, $) {
  let data = 'www.baidu.com'
  //操作数据的函数
  function foo() {
    //用于暴露公有函数
    console.log(`foo() ${data}`)
    $('body').css('background', 'red')
  }
  function bar() {
    //用于暴露公有函数
    console.log(`bar() ${data}`)
    otherFun() //内部调用
  }
  function otherFun() {
    //内部私有的函数
    console.log('otherFun()')
  }
  //暴露行为
  window.myModule = { foo, bar }
})(window, jQuery)

　　调用方法如下代码所示：　　

<!-- 引入的js必须有一定顺序 -->
<script type="text/javascript" src="jquery-1.10.1.js"></script>
<script type="text/javascript" src="module.js"></script>
<script type="text/javascript">
    myModule.foo()
</script>

　　这样做除了保证模块的独立性，还使得模块之间的依赖关系变得明显。

　　但是引入多个script会存在问题：

　　 1、请求过多：多个依赖会发送多个请求；

　　2、依赖模糊：不了解依赖关系导致加载先后顺序出错；

　　3、难以维护：容易出现牵一发而动全身的错误。

四、模块化规范（CommonJS）

1、概述

　　Node 应用由模块组成，采用 CommonJS 模块规范。每个文件就是一个模块，有自己的作用域。在一个文件里面定义的变量、函数、类，都是私有的，对其他文件不可见。在服务器端，模块的加载是运行时同步加载的；在浏览器端，模块需要提前编译打包处理。

2、特点

所有代码都运行在模块作用域，不会污染全局作用域　　
模块可以多次加载，但是只会在第一次加载时运行一次，然后运行结果就被缓存了，以后再加载，就直接读取缓存结果。要想让模块再次运行，必须清除缓存
模块加载的顺序，按照其在代码中出现的顺序

3、基本语法

暴露模块：module.exports.xxx = value或exports.xxx = value
引入模块：require(xxx),如果是第三方模块，xxx为模块名；如果是自定义模块，xxx为模块文件路径

　　CommonJS规范规定，每个模块内部，module变量代表当前模块。这个变量是一个对象，它的exports属性（即module.exports）是对外的接口。加载某个模块，其实是加载该模块的module.exports属性。

　　比如如下的example.js文件，通过module.exports输出变量x和函数addX：

var x = 5;
var addX = function (value) {
    return value + x;
};
module.exports.x = x;
module.exports.addX = addX;

　　引入地方的代码如下：

　　require命令用于加载模块文件。require命令的基本功能是，读入并执行一个JavaScript文件，然后返回该模块的exports对象。如果没有发现指定模块，会报错。

var example1 = require('../api/example.js');
console.log(example1.x); //5
console.log(example1.addX(1)); //6

4、模块的加载机制

　　CommonJS模块的加载机制是，输入的是被输出的值的拷贝。也就是说，一旦输出一个值，模块内部的变化就影响不到这个值。这点与ES6模块化有重大差异。

　　比如如下模块代码：

var counter = 3;

function incCounter() {
    counter++;
}

module.exports = {
    counter: counter,
    incCounter: incCounter,
};

　　在引入的地方输出内部变量counter和改写这个变量的内部方法incCounter。

var counter = require('../api/example.js').counter;
var incCounter = require('../api/example.js').incCounter;

console.log(counter);  // 3
incCounter();
console.log(counter); // 3

　　counter输出以后，模块内部的变化就影响不到counter了。这是因为counter是一个原始类型的值，会被缓存。

五、模块化规范（ES6模块化）

1、概念

　　ES6 模块的设计思想是尽量的静态化，使得编译时就能确定模块的依赖关系，以及输入和输出的变量。CommonJS 和 AMD 模块，都只能在运行时确定这些东西。比如，CommonJS 模块就是对象，输入时必须查找对象属性。

2、语法

　　export命令用于规定模块的对外接口，import命令用于输入其他模块提供的功能。

　　比如如下的模块：

var basicNum = 0;
var add = function (a, b) {
    return a + b;
};
export { basicNum, add };

　　引入的代码如下所示，使用import命令的时候，用户需要知道所要加载的变量名或函数名，否则无法加载。

import {basicNum,add} from "../api/ES6";   //置于顶部


console.log(basicNum);  //0
console.log(add(1,2));  //3

　　为了给用户提供方便，让他们不用阅读文档就能加载模块，就要用到export default命令，为模块指定默认输出。

　模块代码如下所示：

export default function () {
    console.log('foo');
}

　　引入模块的代码如下所示，模块默认输出, 其他模块加载该模块时，import命令可以为该匿名函数指定任意名字。

import fun from "../api/ES6";  //置于顶部

fun();  //foo

3、CommonJS 模块与ES6 模块的差异

　　它们有两个重大差异：

CommonJS 模块输出的是一个值的拷贝，ES6 模块输出的是值的引用。
CommonJS 模块是运行时加载，ES6 模块是编译时输出接口。

　　第二个差异是因为 CommonJS 加载的是一个对象（即module.exports属性），该对象只有在脚本运行完才会生成。

　　而 ES6 模块不是对象，它的对外接口只是一种静态定义，在代码静态解析阶段就会生成。

　　ES6 模块的运行机制与 CommonJS 不一样。ES6 模块是动态引用，并且不会缓存值，模块里面的变量绑定其所在的模块。

六、模块化规范（AMD）

1、概念

　　CommonJS规范加载模块是同步的，也就是说，只有加载完成，才能执行后面的操作。AMD规范则是非同步加载模块，允许指定回调函数。

　　由于Node.js主要用于服务器编程，模块文件一般都已经存在于本地硬盘，所以加载起来比较快，不用考虑非同步加载的方式，所以CommonJS规范比较适用。

　　如果是浏览器环境，要从服务器端加载模块，这时就必须采用非同步模式，因此浏览器端一般采用AMD规范。

2、基本语法

　　定义暴露模块：

//定义没有依赖的模块
define(function(){
   return 模块
})

//定义有依赖的模块
define(['module1', 'module2'], function(m1, m2){
   return 模块
})

　　引入使用模块：

require(['module1', 'module2'], function(m1, m2){
   使用m1/m2
})

　　AMD模块定义的方法非常清晰，不会污染全局环境，能够清楚地显示依赖关系。

　　AMD模式可以用于浏览器环境，并且允许非同步加载模块，也可以根据需要动态加载模块。

七、模块化规范（CMD）

1、概念

　　CMD规范专门用于浏览器端，模块的加载是异步的，模块使用时才会加载执行。CMD规范整合了CommonJS和AMD规范的特点。

2、基本语法

　　定义暴露模块：

//定义没有依赖的模块
define(function(require, exports, module){
  exports.xxx = value
  module.exports = value
})

//定义有依赖的模块
define(function(require, exports, module){
  //引入依赖模块(同步)
  var module2 = require('./module2')
  //引入依赖模块(异步)
    require.async('./module3', function (m3) {
    })
  //暴露模块
  exports.xxx = value
})

　　引入使用模块：

define(function (require) {
  var m1 = require('./module1')
  var m4 = require('./module4')
  m1.show()
  m4.show()
})

八、总结

CommonJS规范主要用于服务端编程，加载模块是同步的，这并不适合在浏览器环境，因为同步意味着阻塞加载，浏览器资源是异步加载的，因此有了AMD CMD解决方案。
ES6 在语言标准的层面上，实现了模块功能，而且实现得相当简单，完全可以取代 CommonJS 和 AMD 规范，成为浏览器和服务器通用的模块解决方案。
AMD规范在浏览器环境中异步加载模块，而且可以并行加载多个模块。不过，AMD规范开发成本高，代码的阅读和书写比较困难，模块定义方式的语义不顺畅。
CMD规范与AMD规范很相似，都用于浏览器编程，依赖就近，延迟执行，可以很容易在Node.js中运行。不过，依赖SPM 打包，模块的加载逻辑偏重。

posted on 2020-12-21 20:57 guo&qi 阅读(237) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

导航

前端模块化

一、什么是模块？

二、模块化开发的好处

三、模块化的演化

四、模块化规范（CommonJS）

五、模块化规范（ES6模块化）

六、模块化规范（AMD）

七、模块化规范（CMD）

八、总结