周元-前端模块化

1. 如何管理外部模块代码
2. 内部模块管理组织
3. 构建工具: 从原始代码 -> 目标代码，编译，依赖图谱

模块化进程

拆分和组合

全局函数 function

function m1(){}
function m2(){}

• 缺点

1. 全局命名污染，容易引起命名冲突；
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

• 优点：减少了全局变量，解决命名冲突；
• 缺点：数据不安全；

IIFE（立即执行函数）

匿名函数自调用(闭包)

• 作用：数据是私有的, 外部只能通过暴露的方法操作
• 编码：将数据和行为封装到一个函数内部, 通过给window添加属性来向外暴露接口

(function(window) {
  let data = 'www.xianzao.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)

模块化的好处：

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

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

• 请求过多；
• 依赖模糊；
• 难以维护；

模块化规范

CommonJS

Node 应用由模块组成，采用 CommonJS 模块规范。每个文件就是一个模块，有自己的作用域。

在浏览器端，模块需要提前编译打包处理。

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

// example.js
var x = 5;
var addX = function (value) {
  return value + x;
};
// 暴露模块
module.exports.x = x;
module.exports.addX = addX;


// 引入模块
var example = require('./example.js');//如果参数字符串以“./”开头，则表示加载的是一个位于相对路径
console.log(example.x); // 5
console.log(example.addX(1)); // 6

• CommonJS规范规定，每个模块内部，module变量代表当前模块。这个变量是一个对象，它的exports属性（即module.exports）是对外的接口。加载某个模块，其实是加载该模块的module.exports属性。
• require命令用于加载模块文件。require命令的基本功能是，读入并执行一个JavaScript文件，然后返回该模块的exports对象。如果没有发现指定模块，会报错。

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

// lib.js
var counter = 3;
function incCounter() {
  counter++;
}
module.exports = {
  counter: counter,
  incCounter: 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是一个原始类型的值，会被缓存。除非写成一个函数，才能得到内部变动后的值。

• 浏览器端实现

Browserify: commonJS => IIFE

Browserify 会对代码进行解析，整理出代码中的所有模块依赖关系，然后把相关的模块代码都打包在一起，形成一个完整的JS文件，这个文件中不会存在 require 这类的模块化语法，变成可以在浏览器中运行的普通JS

AMD

Asynchronous Module Definition

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

CommonJS规范主要用于服务器编程；浏览器端一般采用AMD规范。

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

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

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

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

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

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

CMD

Common Module Definition

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

在 Sea.js 中，所有 JavaScript 模块都遵循 CMD模块定义规范。

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

• AMD与CMD区别:

// CMD
define(function (requie, exports, module) {
    //依赖就近书写
    var module1 = require('Module1');
    var result1 = module1.exec();
    module.exports = {
      result1: result1,
    }
});

// AMD
define(['Module1'], function (module1) {
    var result1 = module1.exec();
    return {
      result1: result1,
    }
});

1. 对依赖的处理：

• AMD推崇依赖前置，即通过依赖数组的方式提前声明当前模块的依赖；
• CMD推崇依赖就近，在编程需要用到的时候通过调用require方法动态引入；

2. 在本模块的对外输出：

• AMD推崇通过返回值的方式对外输出；
• CMD推崇通过给module.exports赋值的方式对外输出；

ES6

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

CommonJS 和 AMD 模块，都只能在运行时确定这些东西。

• export命令用于规定模块的对外接口
• import命令用于输入其他模块提供的功能。
• export default命令，为模块指定默认输出。

ES6 模块与 CommonJS 模块的差异

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

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

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

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

ES6 => ES5(iife)

使用Babel将ES6编译为ES5代码，使用Browserify编译打包js。

UMD

Universal Module Definition

一种javascript通用模块定义规范，让你的模块能在javascript所有运行环境中发挥作用。

umd = commonjs + amd + cmd

(function(root, factory) {
    if (typeof module === 'object' && typeof module.exports === 'object') {
        console.log('是commonjs模块规范，nodejs环境')
        module.exports = factory();
    } else if (typeof define === 'function' && define.amd) {
        console.log('是AMD模块规范，如require.js')
        define(factory)
    } else if (typeof define === 'function' && define.cmd) {
        console.log('是CMD模块规范，如sea.js')
        define(function(require, exports, module) {
            module.exports = factory()
        })
    } else {
        console.log('没有模块环境，直接挂载在全局对象上')
        root.umdModule = factory();
    }
}(this, function() {
    return {
        name: '我是一个umd模块'
    }
}))

讲义

• 前端模块化 (opens new window)