前端模块化详解(完整版)

④定义模块代码

//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 ]

⑤通过node运行app.js

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

(6)浏览器端实现(借助Browserify)

①创建项目结构

|-js|-dist//打包生成文件的目录|-src//源码所在的目录|-module1.js|-module2.js|-module3.js|-app.js//应用主源文件|-index.html//运行于浏览器上|-package.json{"name":"browserify-test","version":"1.0.0"}

②下载browserify

• 全局: npm install browserify -g

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

③定义模块代码(同服务器端)

注意：index.html文件要运行在浏览器上，需要借助browserify将 app.js文件打包编译，如果直接在 index.html引入 app.js就会报错！

④打包处理js

根目录下运行 browserify js/src/app.js-o js/dist/bundle.js

⑤页面使用引入

在index.html文件中引入 <scripttype="text/javascript"src="js/dist/bundle.js"></script>

2.AMD

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

(1)AMD规范基本语法

定义暴露模块:

//定义没有依赖的模块

define(function(){

return 模块

})

//定义有依赖的模块

define([‘module1’, ‘module2’], function(m1, m2){

return 模块

})

引入使用模块:

require([‘module1’, ‘module2’], function(m1, m2){

使用m1/m2

})

(2)未使用AMD规范与使用require.js

通过比较两者的实现方法，来说明使用AMD规范的好处。

• 未使用AMD规范

// dataService.js文件

(function (window) {

let msg = ‘www.baidu.com’

function getMsg() {

return msg.toUpperCase()

}

window.dataService = {getMsg}

})(window)

// alerter.js文件

(function (window, dataService) {

let name = ‘Tom’

function showMsg() {

alert(dataService.getMsg() + ', ’ + name)

}

window.alerter = {showMsg}

})(window, dataService)

// main.js文件

(function (alerter) {

alerter.showMsg()

})(alerter)

// index.html文件

Modular Demo 1: 未使用AMD(require.js)

最后得到如下结果：

这种方式缺点很明显：首先会发送多个请求，其次引入的js文件顺序不能搞错，否则会报错！

• 使用require.js

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

①下载require.js, 并引入

• 官网: http://www.requirejs.cn/

• github : https://github.com/requirejs/requirejs

然后将require.js导入项目: js/libs/require.js

②创建项目结构

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

③定义require.js的模块代码

// dataService.js文件

// 定义没有依赖的模块

define(function() {

let msg = ‘www.baidu.com’

function getMsg() {

return msg.toUpperCase()

}

return { getMsg } // 暴露模块

})

//alerter.js文件

// 定义有依赖的模块

define([‘dataService’], function(dataService) {

let name = ‘Tom’

function showMsg() {

alert(dataService.getMsg() + ', ’ + name)

}

// 暴露模块

return { showMsg }

})

// main.js文件

(function() {

require.config({

baseUrl: ‘js/’, //基本路径 出发点在根目录下

paths: {

//映射: 模块标识名: 路径

alerter: ‘./modules/alerter’, //此处不能写成alerter.js,会报错

dataService: ‘./modules/dataService’

}

})

require([‘alerter’], function(alerter) {

alerter.showMsg()

})

})()

// index.html文件

④页面引入require.js模块:

在index.html引入 <scriptdata-main="js/main"src="js/libs/require.js"></script>

**此外在项目中如何引入第三方库？**只需在上面代码的基础稍作修改：

// alerter.js文件

define([‘dataService’, ‘jquery’], function(dataService, $) {

let name = ‘Tom’

function showMsg() {

alert(dataService.getMsg() + ', ’ + name)

}

$(‘body’).css(‘background’, ‘green’)

// 暴露模块

return { showMsg }

})

// main.js文件

(function() {

require.config({

baseUrl: ‘js/’, //基本路径 出发点在根目录下

paths: {

//自定义模块

alerter: ‘./modules/alerter’, //此处不能写成alerter.js,会报错

dataService: ‘./modules/dataService’,

// 第三方库模块

jquery: ‘./libs/jquery-1.10.1’ //注意：写成jQuery会报错

}

})

require([‘alerter’], function(alerter) {

alerter.showMsg()

})

})()

上例是在alerter.js文件中引入jQuery第三方库，main.js文件也要有相应的路径配置。小结：通过两者的比较，可以得出AMD模块定义的方法非常清晰，不会污染全局环境，能够清楚地显示依赖关系。AMD模式可以用于浏览器环境，并且允许非同步加载模块，也可以根据需要动态加载模块。

3.CMD

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

(1)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()

})

(2)sea.js简单使用教程

①下载sea.js, 并引入

• 官网: http://seajs.org/

• github : https://github.com/seajs/seajs

然后将sea.js导入项目: js/libs/sea.js

②创建项目结构

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

③定义sea.js的模块代码

// module1.js文件

define(function (require, exports, module) {

//内部变量数据

var data = ‘atguigu.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 API_KEY = ‘abc123’

exports.API_KEY = API_KEY

})

// 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.API_KEY)

})

})

// main.js文件

define(function (require) {

var m1 = require(‘./module1’)

var m4 = require(‘./module4’)

m1.show()

m4.show()

})

④在index.html中引入

最后得到结果如下：

4.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 模块的差异

它们有两个重大差异：

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

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

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

下面重点解释第一个差异，我们还是举上面那个CommonJS模块的加载机制例子:

// 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

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

(3) ES6-Babel-Browserify使用教程

简单来说就一句话：使用Babel将ES6编译为ES5代码，使用Browserify编译打包js。

①定义package.json文件

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

②安装babel-cli, babel-preset-es2015和browserify

• npm install babel-cli browserify -g

• npm install babel-preset-es2015 --save-dev

• preset 预设(将es6转换成es5的所有插件打包)

③定义.babelrc文件

{

“presets”: [“es2015”]

}

④定义模块代码

//module1.js文件

// 分别暴露

export function foo() {

console.log(‘foo() module1’)

}

export function bar() {

console.log(‘bar() module1’)

}

//module2.js文件

// 统一暴露

function fun1() {

console.log(‘fun1() module2’)

}

function fun2() {

console.log(‘fun2() module2’)

}

export { fun1, fun2 }

//module3.js文件

// 默认暴露 可以暴露任意数据类项，暴露什么数据，接收到就是什么数据

export default () => {

console.log(‘默认暴露’)

}

// app.js文件

import { foo, bar } from ‘./module1’

import { fun1, fun2 } from ‘./module2’

import module3 from ‘./module3’

foo()

bar()

fun1()

fun2()

module3()

⑤ 编译并在index.html中引入

• 使用Babel将ES6编译为ES5代码(但包含CommonJS语法) : babel js/src-d js/lib

• 使用Browserify编译js : browserify js/lib/app.js-o js/lib/bundle.js

然后在index.html文件中引入

最后得到如下结果：

此外第三方库(以jQuery为例)如何引入呢？首先安装依赖 npm install jquery@1然后在app.js文件中引入

//app.js文件

import { foo, bar } from ‘./module1’

import { fun1, fun2 } from ‘./module2’

import module3 from ‘./module3’

import $ from ‘jquery’

foo()

bar()

fun1()

fun2()
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数前端工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Web前端开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：前端）

最后

资料过多，篇幅有限，需要文中全部资料可以点击这里获取前端面试资料PDF完整版！

自古成功在尝试。不尝试永远都不会成功。勇敢的尝试是成功的一半。

aEhnM2gzaWJBLzY0MA?x-oss-process=image/format,png)

此外第三方库(以jQuery为例)如何引入呢？首先安装依赖 npm install jquery@1然后在app.js文件中引入

//app.js文件

import { foo, bar } from ‘./module1’

import { fun1, fun2 } from ‘./module2’

import module3 from ‘./module3’

import $ from ‘jquery’

foo()

bar()

fun1()

fun2()
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数前端工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Web前端开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-HAyFVdo5-1712649045295)]

[外链图片转存中…(img-cBlxoJql-1712649045296)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！

[外链图片转存中…(img-aSHOALwa-1712649045296)]

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：前端）

最后

[外链图片转存中…(img-uuYOh30h-1712649045296)]

[外链图片转存中…(img-7ThMS23w-1712649045296)]

资料过多，篇幅有限，需要文中全部资料可以点击这里获取前端面试资料PDF完整版！

自古成功在尝试。不尝试永远都不会成功。勇敢的尝试是成功的一半。