前端模块化、模块化规范理解

1.概念

　　　　将一个复杂的程序依据一定的规则(规范)封装成几个块(文件), 并进行组合在一起

　　　　块的内部数据与实现是私有的, 只是向外部暴露一些接口(方法)与外部其它模块通信

2.模块化的发展进程

　　　　1.全局function模式 : 将不同的功能封装成不同的全局函数

　　　　　　编码: 将不同的功能封装成不同的全局函数

　　　　　　问题: 污染全局命名空间, 容易引起命名冲突或数据不安全，而且模块成员之间看不出直接关系

　　　　2.name space模式 : 简单对象封装　

　　　　　　作用: 减少了全局变量，解决命名冲突

　　　　　　问题: 数据不安全(外部可以直接修改模块内部的数据)

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添加属性来向外暴露接口

　　　　　　问题: 如果当前这个模块依赖另一个模块怎么办?

// index.html文件
<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>

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

　　　　　　最后结果：

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

// module.js文件
(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)

 // index.html文件
  <!-- 引入的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>

　　　　　　通过jquery方法将页面的背景颜色改成红色，所以必须先引入jQuery库，就把这个库当作参数传入。这样做除了保证模块的独立性，还使得模块之间的依赖关系变得明显。

3.模块化好处

　　　　避免命名冲突(减少命名空间污染) 更好的分离, 按需加载更高复用性高可维护性

4.引入多个<script>后出现出现问题

　　　　1.请求过多

　　　　　　首先我们要依赖多个模块，那样就会发送多个请求，导致请求过多

　　　　2.依赖模糊

　　　　　　我们不知道他们的具体依赖关系是什么，也就是说很容易因为不了解他们之间的依赖关系导致加载先后顺序出错。

　　　　3.难以维护

　　　　　　以上两种原因就导致了很难维护，很可能出现牵一发而动全身的情况导致项目出现严重的问题。
　　　　　　模块化固然有多个好处，然而一个页面需要引入多个js文件，就会出现以上这些问题。而这些问题可以通过模块化规范来解决。

5.模块化规范

　　　　1.概述

　　　　　　Node 应用由模块组成，采用 CommonJS 模块规范。

　　　　　　每个文件就是一个模块，有自己的作用域。

　　　　　　在一个文件里面定义的变量、函数、类，都是私有的，对其他文件不可见。

　　　　　　在服务器端，模块的加载是运行时同步加载的；在浏览器端，模块需要提前编译打包处理。

　　　　2.特点

　　　　　　所有代码都运行在模块作用域，不会污染全局作用域。

　　　　　　模块可以多次加载，但是只会在第一次加载时运行一次，然后运行结果就被缓存了，以后再加载，就直接读取缓存结果。要想让模块再次运行，必须清除缓存。

　　　　　　模块加载的顺序，按照其在代码中出现的顺序。

　　　　3.基本语法

　　　　　　暴露模块：module.exports = value或exports.xxx = value

　　　　　　引入模块：require(xxx),如果是第三方模块，xxx为模块名；如果是自定义模块，xxx为模块文件路径

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

　　　　4.模块加载机制

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

// lib.js
var counter = 3;
function incCounter() {
  counter++;
}
module.exports = {
  counter: counter,
  incCounter: incCounter,
};
上面代码输出内部变量counter和改写这个变量的内部方法incCounter。

// main.js
var counter = require('./lib').counter;
var incCounter = require('./lib').incCounter;

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

上面代码说明，counter输出以后，lib.js模块内部的变化就影响不到counter了。这是因为counter是一个原始类型的值，会被缓存。除非写成一个函数，才能得到内部变动后的值。

6.ES6模块化

　　　　ES6 模块的设计思想是尽量的静态化，使得编译时就能确定模块的依赖关系，以及输入和输出的变量。

　　　　CommonJS 和 AMD 模块，都只能在运行时确定这些东西。比如，CommonJS 模块就是对象，输入时必须查找对象属性。

　　　　1.es6模块化语法

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

/** 定义模块 math.js **/
var basicNum = 0;
var add = function (a, b) {
    return a + b;
};
export { basicNum, add };
/** 引用模块 **/
import { basicNum, add } from './math';
function test(ele) {
    ele.textContent = add(99 + basicNum);
}

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

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

// export-default.js
export default function () {
  console.log('foo');
}
// import-default.js
import customName from './export-default';
customName(); // 'foo'

　　　　　　模块默认输出, 其他模块加载该模块时，import命令可以为该匿名函数指定任意名字。

　　　　2.ES6 模块与 CommonJS 模块的差异　　　　　

　　　　　　1.CommonJS 模块输出的是一个值的拷贝，ES6 模块输出的是值的引用。

// lib.js
export let counter = 3;
export function incCounter() {
  counter++;
}
// main.js
import { counter, incCounter } from './lib';
console.log(counter); // 3
incCounter();
console.log(counter); // 4

　　　　　　2.CommonJS 模块是运行时加载，ES6 模块是编译时输出接口。

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

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

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

7.总结：

　　　　CommonJS规范主要用于服务端编程，加载模块是同步的，这并不适合在浏览器环境，因为同步意味着阻塞加载，浏览器资源是异步加载的，因此有了AMD CMD解决方案。

　　　　AMD规范在浏览器环境中异步加载模块，而且可以并行加载多个模块。不过，AMD规范开发成本高，代码的阅读和书写比较困难，模块定义方式的语义不顺畅。

　　　　CMD规范与AMD规范很相似，都用于浏览器编程，依赖就近，延迟执行，可以很容易在Node.js中运行。不过，依赖SPM 打包，模块的加载逻辑偏重

　　　　ES6 在语言标准的层面上，实现了模块功能，而且实现得相当简单，完全可以取代 CommonJS 和 AMD 规范，成为浏览器和服务器通用的模块解决方案。

前端模块化、模块化规范理解

猜你喜欢