前端工程化-模块化机制

Posted 2022-12-05 natsu-cc

前言：

---

模块化是一种处理复杂系统分解成为更好的可管理模块的方式，它可以把系统代码划分为一系列职责单一，高度解耦且可替换的模块，系统中某一部分的变化将如何影响其它部分就会变得显而易见，系统的可维护性更加简单易得。

前端开发领域(javascript、CSS、Template)并没有为开发者们提供以一种简洁、有条理地的方式来管理模块的方法。CommonJS(致力于设计、规划并标准化 JavaScript API)的诞生开启了“ JavaScript 模块化的时代”。CommonJS 的模块提案为在服务器端的 JavaScript 模块化做出了很大的贡献，但是在浏览器下的 JavaScript 模块应用很有限。随之而来又诞生了其它前端领域的模块化方案，像 requireJS、SeaJS 等，然而这些模块化方案并不是十分适用 ，并没有从根本上解决模块化的问题。

模块化的理解：

---

前端模块化并不等于 JavaScript 模块化，JavaScript 模块化并不等于异步模块化。

模块的含义：

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

模块化的进化过程：

• 全局function模式 : 将不同的功能封装成不同的全局函数
  处理：将不同的功能封装成不同的全局函数；
  作用：以方法形式封装分离功能；
  弊端：污染全局命名空间, 容易引起命名冲突或数据不安全，而且模块成员之间看不出直接关系；

function fn1()
  ...

function fn2()
  ...

• namespace模式 : 简单对象封装
  处理：以对象方式封装相应功能模块；
  作用：减少了全局变量，解决命名冲突；
  弊端：数据不安全，暴露所有模块成员，内部状态可以被外部改写；

let module= 
  data: 'natsu',
  foo() 
    console.log(this.data);
  

module.data = 'cc' //能直接修改模块内部的数据
module.foo() // cc

• IIFE模式：匿名函数自调用(闭包)
  处理：将数据和行为封装到一个函数内部, 通过给window添加属性来向外暴露接口；
  作用：数据是私有的, 外部只能通过暴露的方法操作；
  弊端：模块依赖问题。

// index.html文件
<script type="text/javascript" src="module.js"></script>
<script type="text/javascript">
    module.foo()	//natsu
    console.log(module.data) //undefined 不能访问模块内部数据
    module.data = 'cc' //不是修改的模块内部的data
    module.foo() //natsu 没有改变
</script>

// module.js文件
(function(window) 
  let data = 'natsu'
  //操作数据的函数
  function foo() 
    //用于暴露有函数
    console.log(data)
  
  //暴露行为
  window.module=  foo  //ES6写法
)(window)

• IIFE模式增强 : 引入依赖
  作用：保证模块的独立性，使得模块之间的依赖关系变得明显。

// index.html文件
  <!-- 引入的js必须有一定顺序（保证依赖关系） -->
  <script type="text/javascript" src="jquery.js"></script>
  <script type="text/javascript" src="module.js"></script>
  <script type="text/javascript">
    module.foo()	//natsu
  </script>

// module.js文件
(function(window, $) 
  let data = 'natsu'
  //操作数据的函数
  function foo() 
    //用于暴露有函数
    console.log(data)
    $('body').css('background', 'red')
  
  //暴露行为
  window.module=  foo 
)(window, jQuery)

模块化的好处：

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

模块化的弊端：

• <script>引入导致请求过多
• 依赖关系模糊
• 难以维护

把所有需要加载的模块按顺序一一加载完毕，当模块很多、依赖关系复杂的情况下会严重影响页面性能，因此我们模块化也需要一定的规范进行约定。

模块化规范：

---

CommonJS：

概述：

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

特点：

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

基本语法：

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

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

require命令用于加载模块文件。require命令的基本功能是，读入并执行一个JavaScript文件，然后返回该模块的exports对象。

模块的加载机制：

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

// count.js
var count= 5;
function addCount() 
  count++;

module.exports = 
  count: count,
  addCount: addCount,
;

// main.js
var count= require('./count').count;
var addCount= require('./count').addCount;

console.log(count);  // 5
addCount();
console.log(count); // 5

count之所以没有改变是因为被加载引入是是值复制，所以后面的修改已经无法对它造成影响。

服务器端实现：

1. 安装node.js，搭建环境；
2. 创建项目结构（使用npm install）；

|-modules
  |-module1.js
  |-module2.js
  |-module3.js
|-app.js
|-package.json

3. 下载第三方模块；
   npm install uniq --save // 数组去重插件

4. 定义模块代码；

//module1.js
module.exports = 
  msg: 'module1',
  foo() 
    console.log(this.msg)
  

//module2.js
module.exports = function() 
  console.log('module2')

//module3.js
exports.foo = function() 
  console.log('foo() module3')

exports.arr = [1, 2, 3, 3, 2]

// app.js文件
// 引入第三方库，应该放置在最前面
let uniq = require('uniq')
let module1 = require('./modules/module1')
let module2 = require('./modules/module2')
let module3 = require('./modules/module3')

module1.foo() //module1
module2() //module2
module3.foo() //foo() module3
console.log(uniq(module3.arr)) //[ 1, 2, 3 ]

5. 通过node运行app.js
   命令行输入node app.js，运行JS文件
   
   

---

浏览器端实现：

1. 创建项目结构（npm install）；

|-js
  |-dist //打包生成文件的目录
  |-src //源码所在的目录
    |-module1.js
    |-module2.js
    |-module3.js
    |-app.js //应用主源文件
|-index.html //运行于浏览器上
|-package.json

2. 下载第三方插件（browserify）；

• 全局: npm install browserify -g
• 局部: npm install browserify --save-dev

3. 定义模块代码（同理服务端代码）

4. 打包处理js
   index.html文件要运行在浏览器上，需要借助browserify将app.js文件打包编译，否则浏览器无法执行。

   运行browserify js/src/app.js -o js/dist/bundle.js 打包编译到指定文件

5. 页面使用引入
   在index.html文件中引入<script type=“text/javascript” src=“js/dist/bundle.js”>

深入了解browserify

---

AMD：

CommonJS规范加载模块是同步的，也就是说，模块加载会阻塞后面的操作。AMD规范则是非同步加载模块，允许指定回调函数。由于Node.js主要用于服务器编程，模块文件一般都已经存在于本地硬盘，所以加载起来比较快，不用考虑非同步加载的方式，所以CommonJS规范比较适用。但是在浏览器环境，要从服务器端加载模块，这时就必须采用非同步模式，因此浏览器端一般采用AMD规范。

基本语法：

• 定义暴露模块：

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

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

• 引入使用模块：

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

---

非AMD规范与AMD规范：

• 未使用AMD规范：

// service.js文件
(function (window) 
  let msg = 'www.baidu.com'
  function getMsg() 
    return msg.toUpperCase()
  
  window.service = getMsg
)(window)

 // alerter.js文件
(function (window, server) 
  let name = 'Tom'
  function showMsg() 
    alert(server.getMsg() + ', ' + name)
  
  window.alerter = showMsg
)(window, server)

// main.js文件
(function (alerter) 
  alerter.showMsg()
)(alerter)

// index.html文件
<h1>未使用AMD</h1>
<script type="text/javascript" src="js/modules/server.js"></script>
<script type="text/javascript" src="js/modules/alerter.js"></script>
<script type="text/javascript" src="js/main.js"></script>

缺点：引入的js文件顺序不能搞错！

---

• 使用AMD规范（require.js）：
  RequireJS是一个工具库，主要用于客户端的模块管理。它的模块管理遵守AMD规范，RequireJS的基本思想是，通过define方法，将代码定义为模块；通过require方法，实现代码的模块加载。

1. 下载require.js，引入插件
2. 创建项目结构

|-js
  |-libs
    |-require.js
  |-modules
    |-alerter.js
    |-dataService.js
  |-main.js
|-index.html

3. 定义require.js的模块代码

// server.js文件 
// 定义没有依赖的模块
define(function() 
  let msg = 'www.baidu.com'
  function getMsg() 
    return msg.toUpperCase()
  
  return  getMsg  // 暴露模块
)

//alerter.js文件
// 定义有依赖的模块
define(['server', 'jquery'], function(server, $) 
  let name = 'Natsu'
  function showMsg() 
    alert(server.getMsg() + ', ' + name)
  
  $('body').css('background', 'green')
  // 暴露模块
  return  showMsg 
)

// main.js文件
(function() 
  require.config(
    baseUrl: 'js/', //基本路径 出发点在根目录下
    paths: 
      //映射: 模块标识名: 路径
      alerter: './modules/alerter', //此处不能写成alerter.js,会报错
      server: './modules/server',
      // 第三方库模块
      jquery: './libs/jquery-1.10.1'
    
  )
  require(['alerter'], function(alerter) 
    alerter.showMsg()
  )
)()

// index.html文件
<h1>使用AMD（require.js）</h1>
<script type="text/javascript" src="js/modules/server.js"></script>

通过两者的比较，可以得出AMD模块定义的方法非常清晰，不会污染全局环境，能够清楚地显示依赖关系。AMD模式可以用于浏览器环境，并且允许非同步加载模块，也可以根据需要动态加载模块。

CMD：

CMD规范专门用于浏览器端，模块的加载是异步的，模块使用时才会加载执行。CMD规范整合了CommonJS和AMD规范的特点。在 Sea.js 中，所有 JavaScript 模块都遵循 CMD模块定义规范。

基本语法：

• 定义暴露模块：

//定义没有依赖的模块
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()
)

sea.js简单使用教程：

1. 下载sea.js, 引入插件
2. 创建项目结构

|-js
  |-libs
    |-sea.js
  |-modules
    |-module1.js
    |-module2.js
    |-module3.js
    |-module4.js
    |-main.js
|-index.html

3. 定义sea.js的模块代码

// module1.js文件
define(function (require, exports, module) 
  //内部变量数据
  var data = 'www.baidu.com'
  //内部函数
  function show() 
    console.log('module1 show() ' + data)
  
  //向外暴露
  exports.show = show
)

// module2.js文件
define(function (require, exports, module) 
  module.exports = 
    msg: 'I Will Back'
  
)

// module3.js文件
define(function(require, exports, module) 
  const name = 'natsu'
  exports.name = name 
)

// module4.js文件
define(function (require, exports, module) 
  //引入依赖模块(同步)
  var module2 = require('./module2')
  function show() 
    console.log('module4 show() ' + module2.msg)
  
  exports.show = show
  //引入依赖模块(异步)
  require.async('./module3', function (m3) 
    console.log('异步引入依赖模块3  ' + m3.name )
  )
)

// main.js文件
define(function (require) 
  var m1 = require('./module1')
  var m4 = require('./module4')
  m1.show()
  m4.show()
)

4. 在index.html中引入

<script type="text/javascript" src="js/libs/sea.js"></script>
<script type="text/javascript">
  seajs.use('./js/modules/main')
</script>

ES6模块化：

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

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

/** 定义模块 add.js **/
var operate = 'add';
var add = function (a, b) 
    return a + b;
;
export  operate, add ;

/** 引用模块 **/
import  operate, add  from './add';
function test() 
    console.log(operate, add(1 + 99));

test();

使用import命令的时候，用户需要知道所要加载的变量名或函数名，否则无法加载。为了给用户提供方便，让他们不用阅读文档就能加载模块，就要用到export default命令，为模块指定默认输出。

// default.js
export default function () 
  console.log('natsu');

// import.js
import customName from './default';
customName(); // 'natsu'

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

ES6 模块与 CommonJS 模块的差异：

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

CommonJS 加载的是一个对象（即module.exports属性），该对象只有在脚本运行完才会生成。而 ES6 模块不是对象，它的对外接口只是一种静态定义，在代码静态解析阶段就会生成。

ES6-Babel-Browserify使用教程：

1. 定义package.json文件

 
   "name" : "es6-babel-browserify",
   "version" : "1.0.0"
 

2. 安装babel-cli, babel-preset-es2015和browserify

• npm install babel-cli browserify -g
• npm install babel-preset-es2015 --save-dev
• preset 预设(将es6转换成es5的所有插件打包)

3. 定义.babelrc文件

    "presets": ["es2015"]
  

4. 定义模块代码

//module1.js文件
// 分别暴露
export function foo() 
  console.log('foo() module1')

export function bar() 
  console.以上是关于前端工程化-模块化机制的主要内容，如果未能解决你的问题，请参考以下文章
 
 前端工程化-loader机制
 前端工程化-loader机制
 大前端训练营part2/02-01
 day21
 前端工程化-插件机制
 前端工程化-插件机制