在es6之前,js不像其他语言自带成熟的模块化功能,页面只能靠插入一个个script标签来引入自己的或第三方的脚本,并且容易带来命名冲突的问题。js社区做了很多努力,在当时的运行环境中,实现"模块"的效果。
通用的js模块化标准有CommonJS与AMD,前者运用于node环境,后者在浏览器环境中由Require.js等实现。此外还有国内的开源项目Sea.js,遵循CMD规范。(目前随着es6的普及已经停止维护,不论是AMD还是CMD,都将是一段历史了)
浏览器端js加载器
实现一个简单的js加载器并不复杂,主要可以分为解析路径、下载模块、解析模块依赖、解析模块四个步骤。
首先定义一下模块。在各种规范中,通常一个js文件即表示一个模块。那么,我们可以在模块文件中,构造一个闭包,并传出一个对象,作为模块的导出:
define(factory() { var x = { a: 1 }; return x; });
define函数接收一个工厂函数参数,浏览器执行该脚本时,define函数执行factory,并把它的return值存储在加载器的模块对象modules里。
如何标识一个模块呢?可以用文件的uri,它是唯一标识,是天然的id。
文件路径path有几种形式:
因此,需要一个resolvePath函数来将不同形式的path解析成uri,参照当前页面的文件路径来解析。
接着,假设我们需要引用a.js与b.js两个模块,并设置了需要a与b才能执行的回调函数f。我们希望加载器去拉取a与b,当a与b都加载完成后,从modules里取出a与b作为参数传给f,执行下一步操作。这里可以用观察者模式(即订阅/发布模式)实现,创建一个eventProxy,订阅加载a与加载b事件;define函数执行到最后,已经把导出挂载modules里之后,emit一个本模块加载完成的事件,eventProxy收到后检查a与b是否都加载完成,如果完成,就传参给f执行回调。
同理,eventProxy也可以实现模块依赖加载
// a.js define([ 'c.js', 'd.js' ], factory (c, d) { var x = c + d; return x; });
define函数的第一个参数可以传入一个依赖数组,表示a模块依赖c与d。define执行时,告诉eventProxy订阅c与d加载事件,加载好了就执行回调函数f存储a的导出,并emit事件a已加载。
浏览器端加载脚本的原始方法是插入一个script标签,指定src之后,浏览器开始下载该脚本。
那么加载器中的模块加载可以用dom操作实现,插入一个script标签并指定src,此时该模块为下载中状态。
PS:浏览器中,动态插入script标签与初次加载页面dom时的script加载方式不同:
初次加载页面,浏览器会从上到下顺序解析dom,碰到script标签时,下载脚本并阻塞dom解析,等到该脚本下载、执行完毕后再继续解析之后的dom(现代浏览器做了preload优化,会预先下载好多个脚本,但执行顺序与它们在dom中顺序一致,执行时阻塞其他dom解析)
动态插入script,
var a = document.createElement('script'); a.src='xxx'; document.body.appendChild(a);
浏览器会在该脚本下载完成后执行,过程是异步的。
下载完成后执行上述的操作,解析依赖->加载依赖->解析本模块->加载完成->执行回调。
模块下载完成后,如何在解析它时知道它的uri呢?有两种发发,一种是用srcipt.onload获取this对象的src属性;一种是在define函数中采用document.currentScript.src。
实现基本的功能比较简单,代码不到200行:
var zmm = { _modules: {}, _configs: { // 用于拼接相对路径 basePath: (function (path) { if (path.charAt(path.length - 1) === 'https://www.jb51.net/') { path = path.substr(0, path.length - 1); } return path.substr(path.indexOf(location.host) + location.host.length + 1); })(location.href), // 用于拼接相对根路径 host: location.protocol + '//' + location.host + 'https://www.jb51.net/' } }; zmm.hasModule = function (_uri) { // 判断是否已有该模块,不论加载中或已加载好 return this._modules.hasOwnProperty(_uri); }; zmm.isModuleLoaded = function (_uri) { // 判断该模块是否已加载好 return !!this._modules[_uri]; }; zmm.pushModule = function (_uri) { // 新模块占坑,但此时还未加载完成,表示加载中;防止重复加载 if (!this._modules.hasOwnProperty(_uri)) { this._modules[_uri] = null; } }; zmm.installModule = function (_uri, mod) { this._modules[_uri] = mod; }; zmm.load = function (uris) { var i, nsc; for (i = 0; i < uris.length; i++) { if (!this.hasModule(uris[i])) { this.pushModule(uris[i]); // 开始加载 var nsc = document.createElement('script'); nsc.src = uri; document.body.appendChild(nsc); } } }; zmm.resolvePath = function (path) { // 返回绝对路径 var res = '', paths = [], resPaths; if (path.match(/.*:\/\/.*/)) { // 绝对路径 res = path.match(/.*:\/\/.*?\//)[0]; // 协议+域名 path = path.substr(res.length); } else if (path.charAt(0) === 'https://www.jb51.net/') { // 相对根路径 /开头 res = this._configs.host; path = path.substr(1); } else { // 相对路径 ./或../开头或直接文件名 res = this._configs.host; resPaths = this._configs.basePath.split('https://www.jb51.net/'); } resPaths = resPaths || []; paths = path.split('https://www.jb51.net/'); for (var i = 0; i < paths.length; i++) { if (paths[i] === '..') { resPaths.pop(); } else if (paths[i] === '.') { // do nothing } else { resPaths.push(paths[i]); } } res += resPaths.join('https://www.jb51.net/'); return res; }; var define = zmm.define = function (dependPaths, fac) { var _uri = document.currentScript.src; if (zmm.isModuleLoaded(_uri)) { return; } var factory, depPaths, uris = []; if (arguments.length === 1) { factory = arguments[0]; // 挂载到模块组中 zmm.installModule(_uri, factory()); // 告诉proxy该模块已装载好 zmm.proxy.emit(_uri); } else { // 有依赖的情况 factory = arguments[1]; // 装载完成的回调函数 zmm.use(arguments[0], function () { zmm.installModule(_uri, factory.apply(null, arguments)); zmm.proxy.emit(_uri); }); } }; zmm.use = function (paths, callback) { if (!Array.isArray(paths)) { paths = [paths]; } var uris = [], i; for (i = 0; i < paths.length; i++) { uris.push(this.resolvePath(paths[i])); } // 先注册事件,再加载 this.proxy.watch(uris, callback); this.load(uris); }; zmm.proxy = function () { var proxy = {}; var taskId = 0; var taskList = {}; var execute = function (task) { var uris = task.uris, callback = task.callback; for (var i = 0, arr = []; i < uris.length; i++) { arr.push(zmm._modules[uris[i]]); } callback.apply(null, arr); }; var deal_loaded = function (_uri) { var i, k, task, sum; // 当一个模块加载完成时,遍历当前任务栈 for (k in taskList) { if (!taskList.hasOwnProperty(k)) { continue; } task = taskList[k]; if (task.uris.indexOf(_uri) > -1) { // 查看这个任务中的模块是否都已加载好 for (i = 0, sum = 0; i < task.uris.length; i++) { if (zmm.isModuleLoaded(task.uris[i])) { sum ++; } } if (sum === task.uris.length) { // 都加载完成 删除任务 delete(taskList[k]); execute(task); } } } }; proxy.watch = function (uris, callback) { // 先检查一遍是否都加载好了 for (var i = 0, sum = 0; i < uris.length; i++) { if (zmm.isModuleLoaded(uris[i])) { sum ++; } } if (sum === uris.length) { execute({ uris: uris, callback: callback }); } else { // 订阅新加载任务 var task = { uris: uris, callback: callback }; taskList['' + taskId] = task; taskId ++; } }; proxy.emit = function (_uri) { console.log(_uri + ' is loaded!'); deal_loaded(_uri); }; return proxy; }();
循环依赖问题
"循环加载"指的是,a脚本的执行依赖b脚本,而b脚本的执行又依赖a脚本。这是一种应该尽量避免的设计。
浏览器端
用上面的zmm工具加载模块a: