前端模块化方案

前端模块化方案

前言

各位在看本片文章之前可以先阅读以下文章，了解下什么是模块化？为什么要模块化？模块化演进过程是怎么样的？什么是模块化规范？

Javascript模块化编程（一）：模块的写法

Javascript模块化编程（二）：AMD规范

Javascript模块化编程（三）：require.js的用法

Javascript模块化编程（四）：CommonJS规范

看过以上的博文之后，相信你对模块化有所了解，模块化的开发方式可以提高代码复用率，方便进行代码的管理。通常一个文件就是一个模块，有自己的作用域，只向外暴露特定的变量和函数。目前流行的js模块化规范有CommonJS、AMD、CMD以及ES6的模块系统。接下来先简单介绍各规范下的模块化实现方式。

前端模块化方案简介

一、CommonJS

​ Node.js是commonJS规范的主要实践者，它有四个重要的环境变量为模块化的实现提供支持：module、exports、require、global。实际使用时，用module.exports定义当前模块对外输出的接口（不推荐直接用exports），用require加载模块。

//定义模块math.js
var basicNum = 0;
function add(a, b) {
    return a + b;
}
module.exports = { //在这里写上需要向外暴露的函数、变量
    add: add,
    basicNum: basicNum
}
 
//引用自定义的模块时，参数包含路径，可省略.js
var math = require('./math');
math.add(2, 5);
 
//引用核心模块时，不需要带路径
var http = require('http');
http.createService(...).listen(3000);

​ commonJS用同步的方式加载模块。在服务端，模块文件都存在本地磁盘，读取非常快，所以这样做不会有问题。但是在浏览器端，限于网络原因，更合理的方案是使用异步加载。

二、AMD和require.js

AMD规范采用异步方式加载模块，模块的加载不影响它后面语句的运行。所有依赖这个模块的语句，都定义在一个回调函数中，等到加载完成之后，这个回调函数才会运行。这里介绍用require.js实现AMD规范的模块化：用require.config()指定引用路径等，用define()定义模块，用require()加载模块。

首先我们需要引入require.js文件和一个入口文件main.js。main.js中配置require.config()并规定项目中用到的基础模块。

/** 网页中引入require.js及main.js **/
<script src="js/require.js" data-main="js/main"></script>
 
/** main.js 入口文件/主模块 **/
//首先用config()指定各模块路径和引用名
require.config({
    baseUrl: "js/lib",
    paths: {
        "jquery": "jquery.min",  //实际路径为js/lib/jquery.min.js
        "underscore": "underscore.min",
    }
});
//执行基本操作
require(["jquery","underscore"],function($,_){
    // some code here
});

​ 引用模块的时候，我们将模块名放在[]中作为reqiure()的第一参数；如果我们定义的模块本身也依赖其他模块，那就需要将它们放在[]中作为define()的第一参数。

//定义math.js模块
define(function () {
    var basicNum = 0;
    var add = function (x, y) {
        return x + y;
    };
    return {
        add: add,
        basicNum :basicNum
    };
});
//定义一个依赖underscore.js的模块
define(['underscore'],function(_){
    var classify = function(list){
        _.countBy(list,function(num){
            return num >30 ? 'old': 'young';
        })
    };
    return {
        classify :classify
    };
})
 
//引用模块，将模块放在[]内
require([jquery,math],function($,math){
    var sum = math.add(10,20);
    $("#sum").html(sum);
});

三、CMD和sea.js

require.js在申明依赖的模块时会在第一之间加载并执行模块内的代码：

define(["a", "b", "c", "d", "e", "f"], function(a, b, c, d, e, f) {
     // 等于在最前面声明并初始化了要用到的所有模块
    if (false) {
        // 即便没用到某个模块 b，但 b 还是提前执行了
        b.foo()
    }
});

​ CMD是另一种js模块化方案，它与AMD很类似，不同点在于：AMD 推崇依赖前置、提前执行，CMD推崇依赖就近、延迟执行。此规范其实是在sea.js推广过程中产生的。

/** AMD写法 **/
define(["a", "b", "c", "d", "e", "f"], function(a, b, c, d, e, f) {
     // 等于在最前面声明并初始化了要用到的所有模块
    a.doSomething();
    if (false) {
        // 即便没用到某个模块 b，但 b 还是提前执行了
        b.doSomething()
    }
});
 
/** CMD写法 **/
define(function(require, exports, module) {
    var a = require('./a'); //在需要时申明
    a.doSomething();
    if (false) {
        var b = require('./b');
        b.doSomething();
    }
});
 
/** sea.js **/
// 定义模块 math.js
define(function(require, exports, module) {
    var $ = require('jquery.js');
    var add = function(a,b){
        return a+b;
    }
    exports.add = add;
});
// 加载模块
seajs.use(['math.js'], function(math){
    var sum = math.add(1+2);
});

四、ES6 Module

ES6 在语言标准的层面上，实现了模块功能，而且实现得相当简单，旨在成为浏览器和服务器通用的模块解决方案。其模块功能主要由两个命令构成：export和import。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命令的时候，用户需要知道所要加载的变量名或函数名。其实ES6还提供了export default命令，为模块指定默认输出，对应的import语句不需要使用大括号。这也更趋近于ADM的引用写法。

/** export default **/
//定义输出
export default { basicNum, add };
//引入
import math from './math';
function test(ele) {
    ele.textContent = math.add(99 + math.basicNum);
}

​ ES6的模块不是对象，import命令会被 JavaScript 引擎静态分析，在编译时就引入模块代码，而不是在代码运行时加载，所以无法实现条件加载。也正因为这个，使得静态分析成为可能。

其他可以参考以下博文：

前端工程师必备：前端的模块化

前端模块化问题解答

前端模块化中module.exports、exports、export和export default，import和require区别与联系

一、首先搞清楚一个基本问题：

require导入，import module.exports和exports导出，都是与属于CommonJS模块规范！

import导入，export和export default导出，都是属于ES6语法！

二、module.exports和exports的区别与联系

Node应用由模块组成，采用CommonJS模块规范。根据这个规范，每个文件就是一个模块，有自己的作用域。在一个文件里面定义的变量、函数、类，都是私有的，对其他文件不可见。

普及下：

• 在javascript中有2种作用域：全局作用域和函数作用域，在浏览器端， 全局作用域就是window对象的属性，函数作用域就是函数内部的对象属性。
• 在node中，也有2种作用域：全局作用域和模块作用域，因此要想实现在nodejs中多个文件中分享变量，就必须定义成全局对象 (global)的属性， global定义的变量，在任何地方都可以使用，类似于浏览器端定义在全局 范围中的变量。

CommonJS规范规定，每个模块内部，module变量代表当前模块。如果使用node命令去console.log(module)，你会发现这个变量是一个对象，它的exports属性（即module.exports）是对外的接口。加载某个模块，其实是加载该模块的module.exports属性。

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

上面代码通过module.exports输出变量x和函数addX。

require方法用于加载模块。

var example = require('./example.js');

console.log(example.x); // 5
console.log(example.addX(1)); // 6

看了刚刚这段commonjs规范上面的介绍可以知道module.exports 和 exports 的关系 :

其实exports变量是指向module.exports，也就是说exports = module.exports 都指向同一个内存地址，加载模块实际是加载该模块的module.exports。

var exports = module.exports;
其实就是干了这么一件事
exports = module.exports = {};

于是我们可以直接在 exports 对象上添加方法，表示对外输出的接口，如同在module.exports上添加一样。注意，不能直接将exports变量指向一个值，因为这样等于切断了exports与module.exports的联系。直接看例子明了。

// a.js
let a = 100;

exports.a = 200;
// 然后把a指向另外一个地址
exports = '另外的地址'

// b.js
// 引入模块

var example = require('./a.js')
console.log(example.a)  // 200

可以看出，require导出的内容是module.exports的内容，而不是exports的，简单来说，exports用来帮助module.exports操作内存中的数据。来看下nodejs中require的加载机制。

function require(...) {  
  var module = { exports: {} };
  ((module, exports) => {
    // 你的被引入代码 Start
    // var exports = module.exports = {}; (默认都有的)
    function some_func() {};
    exports = some_func;
    // 此时，exports不再挂载到module.exports，
    // export将导出{}默认对象
    module.exports = some_func;
    // 此时，这个模块将导出some_func对象，覆盖exports上的some_func    
     // 你的被引入代码 End
  })(module, module.exports);
 // 不管是exports还是module.exports，最后返回的还是module.exports 
  return module.exports;
}

console.log(exports); // {}  
console.log(module.exports);  // {}  
console.log(exports === module.exports);    // true  
console.log(exports == module.exports);        // true  
console.log(module);
/**
 Module {
  id: '.',
  exports: {},
  parent: null,
  filename: '/Users/larben/Desktop/demo.js',
  loaded: false,
  children: [],
  paths:
   [ '/Users/larben/Desktop/node_modules',
     '/Users/larben/node_modules',
     '/Users/node_modules',
     '/node_modules' ] }
 */

一句话概括重点：exports就是module.exports的引用，最简单避错的方法就是尽量都用 module.exports。

如果不太理解，提供以下博文作为参考：

module.exports和moudle和exports的区别很容易理解

exports 和 module.exports 的区别

四、export和export default的区别与联系

模块功能主要由：export和import构成。export导出模块的对外接口，import命令导入其他模块暴露的接口。

export其实和export default就是写法上面有点差别，一个是导出一个个单独接口，一个是默认导出一个整体接口。使用import命令的时候，用户需要知道所要加载的变量名或函数名，否则无法加载。这里就有一个简单写法不用去知道有哪些具体的暴露接口名，就用export default命令，为模块指定默认输出。

export可以这样写

// testA.js
var f = 'Miel';
var name = 'Jack';
var data= 1988;

export {f, name, data};

使用export命令定义了模块的对外接口以后，其他 JS 文件就可以通过import命令加载这个模块。

// main.js
import {f, name, data} from './testA';

export default可以这样写

// export-default.js
export default function () {
  console.log('foo');
}
// 或者写成

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

下面比较一下export default和export 输出。

// 第一组
export default function car() { // 输出
  // ...
}

import car from 'car'; // 输入

// 第二组
export function car2() { // 输出
  // ...
};

import {car2} from 'car2'; // 输入

可以看到第一组是使用export default，import语句不需要使用大括号；第二组使用export，对应的import语句需要使用大括号，一个模块只能有一个默认输出，所以export default只能使用一次。

再看个例子直接就明白了

//a.js
export const a = '100'  // 方式一
const Stark = function(){ 
    console.log('im ironman')
}// 方式二

export { Stark }


// export default方式
const mark85 = 1000
export default mark85

// b.js
import { a, Stark } from './a.js';  // 引入export导出的数据
import ironman from './a.js' // 引入export default导出的数据
import * as hero from './a.js' // 集合成对象一并导出，es6语法的本意是想将 es6 模块的所有命名输出以及defalut输出打包成一个对象赋值给hero变量。as简单的说就是取一个别名,export中可以用，import中其实可以用：

console.log(a) // 100
Stark(); // im ironman
console.log(ironman) // 1000
console.log(hero.a) // 100
console.log(hero.default) // 1000

一句话重点：export 和 export default的区别：

• 在一个文件或模块中，export、import可以有多个，export default仅有一个；
• 通过export方式导出，在导入时要加{ }，export default则不需要；
• export能直接导出变量表达式，export default不行。

五、import和require的区别与联系
看了上面其实已经清楚了，import和require是分别属于ES6和CommonJS的两种导入模块的语法而已。

其他可以参考以下博文：

import、require、export、module.exports 混合使用详解

*彻底搞清楚javascript中的require、import和export