备案控制台
开发者社区 开发与运维 文章 正文

seajs 3.0.0 源码阅读笔记

2017-11-23 1231
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

写笔记的时候才注意到我看的源代码是 3.0.0 的，但是官方发布的最新版本是 2.3.0。相信大部分是相同的，所以先把这个记完，再看一次 2.3.0 的代码。

seajs 的源代码可以在 github上获取。seajs 在文档“如何参与开发”中说明了阅读顺序，当然为了便于阅读，在了解了目录结构之后，我直接阅读了合并好的 sea-debug.js。

整个seajs采用的是2空格缩进，避免分号的写法，我不是很习惯，但不影响阅读。

文件/目录结构

文档中各个源文件所包含的内容大致如下：

intro.js 
文件头

sea.js 
定义全局 global.seajs 对象和 seajs.data 对象

util-lang.js，语言相关工具 
定义用于判断对象类型的 isXxxxx() 函数，以及一个与语言无关的 cid()。

util-events.js 
定义 seajs 的事件处理相关函数，包括 on()、off()、emit()

util-path.js 
定义用于路径处理的工具函数

util-request.js 
定义请求文件的工具函数 seajs.request() 等

util-deps.js 
定义用于分析依赖关系的 parseDependencies()

module.js 
seajs 的核心，模块类。 
也包含部分 seajs 的方法

config.js 
定义 seajs.config()，以及 data 部分属性的默认值

所以合并之后的整个 seajs 代码看起来就像这样

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
( function (global, undefiend) {
   global.seajs = {
     data: {}
   }
   var  isObject =  function () {}
   var  isString =  function () {}
   var  isArray =  function () {}
   var  isFunction =  function () {}
   var  cid =  function () {}
   data.events = {}
   seajs.on =  function () {}
   seajs.off =  function () {}
   seajs.emit =  function () {}
   // path utils, and
   seajs.resolve =  function () {}
   var  loaderDir
   var  parseDependencies =  function () {}
   function  Module() {}
   seajs.config =  function () {}
})( this );

isXxxx 用于判断对象类型

首先是定义了一个产生 isXxxx 的函数工厂 isType()

1
2
3
4
5
function  isType(type) {
   return  function (obj) {
     return  {}.toString.call(obj) ==  "[object "  + type +  "]"
   }
}


从这个工厂的代码可以看出来，isXxxx() 主要是通过 Object.prototype.toString 的值来判断对象类型的。

当然也有例外：

1
2
// 毕竟 Array.isArray() 是 [native code]，效果会高得多
var  isArray = Array.isArray || isType( "Array" )


这里有几件事情我不是很明白：

  1. 就是为什么不使用 typeof 运算符来判断类型，一般语言中运算符实现会比比较字符串快得多。

  2. {}.toString.call(obj) 和 Object.prototype.toString.call(obj) 的作用是一样的，但是在运行时，每执行一次 isXxxx 就会产生一个新的 {} 对象；而 Object.prototype 始终都是同一个对象，似乎可以减少不少开销

  3. jQuery 的 isFunction() 等方法都是通过 jQuery.type() 来实现的，而 jQuery.type 中则是通过定义了一个 class2type 字典对象来做类型映射，


2014-09-09 补充

我在 seajs 的 issue 上问了这个问题，于是上面的几个问题就都找到答案了：

https://github.com/seajs/seajs/issues/1314


参考玉伯的博客

https://github.com/lifesinger/lifesinger.github.com/issues/175

1
2
3
jQuery.each( "Boolean Number String Function Array Date RegExp Object Error" .split( " " ),  function (i, name) {
     class2type[  "[object "  + name +  "]"  ] = name.toLowerCase();
});


这种作法也会比每次都拼字符串（"[object " + type + "]"）来比较要效率高一些吧。

不过 seajs 和 jquery 都没有直接依赖 typeof 运算符来实现 isXxxx，我相信绝对不是偶然，一定有啥原因，不过这个原因我目前就不清楚了，希望玉伯能看到这个博客，稍作解释

事件

seajs 只为全局对象 seajs 添加了事件处理。事件的回调函数链保存在 seajs.data.events 中，以事件名称为 key，Array 对象保存的回调函数链为 value。

因为 seajs 的事件主要为了插件而定义，所以对参数并没有严格的校验。比如

1
2
3
4
5
// 自定义一个比较奇葩的事件，这不会报错
seajs.on( null ,  "fake callback" );
// 但是执行就会出错了
seajs.emit( "null" )
// 输出：TypeError: string is not a function


看样子，插件开发者得自己注意下这个问题了。

看完 seajs 的源码，大概定义了这么一些事件

  1. error，貌似跟 NodeJS 有点关系，没仔细看

  2. load，在模块对象状态变成 LOADING 后触发，参数是所有依赖模块的 URI。

    1
    2
    3
       // Emit `load` event for plugins such as combo plugin
       var  uris = mod.resolve()
       emit( "load" , uris)

  3. exec，在模块对象状态变成 EXECUTED 后触发，参数就是模块对象本身

  4. fetch，在模块对象状态刚变成 FETECHING 时触发，参数是一个临时对象emitData，事件结果保存在 emitData.requestUri，用于后面的 request 请求数据。

    1
    2
    3
    4
       // Emit `fetch` event for plugins such as combo plugin
       var  emitData = { uri: uri }
       emit( "fetch" , emitData)
       var  requestUri = emitData.requestUri || uri

  5. request，在 fetch 事件后对 emitData.requestUri || uri 进行了处理之后，通过 seajs.request() 请求数据之前触发，参数是一个临时对象，变量名复用的 emitData。事件处理完成后根据 emitData.requested 的值来判断是否需要调用 seajs.request 请求数据。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
       // Emit `request` event for plugins such as text plugin
       emit( "request" , emitData = {
         uri: uri,
         requestUri: requestUri,
         onRequest: onRequest,
         charset: isFunction(data.charset)
           ? data.charset(requestUri) ||  'utf-8'
           : data.charset
       })
       if  (!emitData.requested) {
         // ...
       }

  6. resolve，在 Module.resolve 中调用 seajs.resolve() 之前触发，参数是一个临时对象 emitData。事件中如果产生了有效的 emitData.uri，则不再调用seajs.resolve()

    1
    2
    3
    4
       // Emit `resolve` event for plugins such as text plugin
       var  emitData = { id: id, refUri: refUri }
       emit( "resolve" , emitData)
       return  emitData.uri || seajs.resolve(emitData.id, refUri)

  7. config，在 seajs.config() 中，完成对 config 对象的处理之后触发，参数就是 config 对象。

    1
    2
    3
    4
    5
    seajs.config =  function (configData) {
       // ...
       emit( "config" , configData)
       return  seajs
    }

Module 类

Module 类才是 seajs 的重头戏，核心的核心。seajs 作为一个模块加载器，所以模块都是以一个 Module 对象保存在 cachedMods 中的。

1
var  cachedMods = seajs.cache = {}

每个模块都有 8 种状态，它一定是在这 8 种状态之一，而且貌似状态改变还是不可逆的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
var  STATUS = Module.STATUS = {
   // 没定义状态值为 0 的状态常量，这是初始状态
   // 1 - The `module.uri` is being fetched
   FETCHING: 1,
   // 2 - The meta data has been saved to cachedMods
   SAVED: 2,
   // 3 - The `module.dependencies` are being loaded
   LOADING: 3,
   // 4 - The module are ready to execute
   LOADED: 4,
   // 5 - The module is being executed
   EXECUTING: 5,
   // 6 - The `module.exports` is available
   EXECUTED: 6,
   // 7 - 404
   ERROR: 7
}

其中 SAVED 状态可以理解为 FETCHED 状态。除了初始状态 0 和错误状态 ERROR: 7 之外，其它 6 个状态都是成对出现的，即 ING 状态和 ED 状态，这三对状态清晰的划分出来三个处理过程：fetch、load、exec，对应于模块对象的 3 个方法：fetch(), load(), exec()。

从代码内容来看，这三个主要过程方法主要功能分别可以用一句话说明：

  • fetch，从 URL 加载模块定义，得到 factory 函数，并将 factory 函数赋值给对应的模块对象（通过 Module.get() 创建或获取）；

  • load，fetch 并 load 所有依赖模块，并在保证所有依赖模块都是 LOADED 状态之后，调用入口模块（_entry）的 callback（貌似只有通过 seajs.use() 创建的匿名模块才有 callback）

  • exec，在调用这个方法的时候，可以保证所有依赖模块都已经是 LOADED 状态了，所以 exec就只是简单的执行 factory 函数，并返回 exports。factory 只执行一次，然后将 exports 缓存下来。

现在来看看入口函数 seajs.use()、模块定义函数 define()、模块关系过程处理方法 fetch(),load(), exec() 的主要调用关系：

1
2
3
4
5
6
// seajs.use 只调用了 Module.use，所以它们的调用关系可以看作等同
seajs.use = Module.use =  function () {
   Module.get()
   exec()         // 通过 _entry.callback 调用
   load()
}
1
2
3
define = Module.define =  function () {
   Module.save(id, factory)
}
1
2
3
4
Module.prototype.fetch =  function () {
   define()       // 通过 seajs.request() 调用
   load()
}
1
2
3
4
5
6
7
8
9
Module.prototype.load =  function () {
   pass()
   fetch()
   // [递归]
   // 结束的条件是 _entry.remain === 1，
   // 即当前是最后一个依赖模块
   // 递归结束时调用 _entry.callback，即调用了 exec
   load()  
}
1
2
3
Module.prototype.exec =  function () {
   exec()         // 通过 define 中定义的 factory 函数调用
}
1
2
3
4
5
6
Module.prototype.pass =  function () {
   // [递归]
   // 结束条件是把 _entry 传递到最末一层依赖
   // 递归过程通过 _entry.remain 进行了引用记数
   pass()
}

各函数和方法具体处理过程看代码就明白了，因为递归关系有点复杂，还有一些回调关系在里面，所以看起来有点绕，不过还算是看得明白。

http://seajs.org 引用的 seajs 版本是 2.2.1，从这引页面的控制输出 seajs.Modules.prototype 来看，并没有定义 pass() 方法，所以对 _entry 的处理可能会有点不一样，稍后看了 seajs 2.2.3 版本的代码就知道了。

本文转自边城__ 51CTO博客，原文链接：http://blog.51cto.com/jamesfancy/1549706，如需转载请自行联系原作者
文章标签：
JavaScript
缓存
开发者
科技小先锋
目录
相关文章
长沙-杨磊
|
缓存 前端开发 JavaScript
浅浅阅读umi中InitialState插件源码 - 杨磊
InitialState插件源码的简要介绍
长沙-杨磊
831 0
浅浅阅读umi中InitialState插件源码 - 杨磊
greework
|
11月前
|
安全 前端开发 索引
谈一谈|MkDocs介绍及应用
谈一谈|MkDocs介绍及应用
greework
207 0
维李设论
|
JSON 前端开发 数据可视化
umi3源码探究简析
作为蚂蚁金服整个生态圈最为核心的部分，umi可谓是王冠上的红宝石，因而个人认为对于整个umi架构内核的学习及设计哲学的理解，可能比如何使用要来的更为重要；作为一个使用者，希望能从各位大佬的源码中汲取一些养分以及获得一些灵感
维李设论
188 0
前端歌谣
|
JavaScript
js基础笔记学习275练习5之三
js基础笔记学习275练习5之三
前端歌谣
57 0
js基础笔记学习275练习5之三
前端歌谣
|
JavaScript
js基础笔记学习274练习5之二
js基础笔记学习274练习5之二
前端歌谣
48 0
js基础笔记学习274练习5之二
长沙-杨磊
|
缓存 前端开发 JavaScript
浅浅阅读umi中InitialState插件源码
InitialState插件源码的简要介绍
长沙-杨磊
487 1
浅浅阅读umi中InitialState插件源码
嘿嘿不务正业
|
设计模式 JavaScript 前端开发
看文档不如看源码系列热身 - Redux 源码全解析
众所周知，前端轮子太多，大部分同学每次学习新轮子都是学完不用就忘。我最近看一些库，其实这些库的实现都很简单，但是文档往往又很多，甚至还有些文档说的不清不楚，偶尔用到了都要去查文档，细节一点的东西文档又往往无法体现，感觉还不如将看文档的时间用来看源码。这些库的源码往往很精简，看完了既能知道如何使用，还能知其所以然，不亏。所以有了这个系列。
嘿嘿不务正业
71 0
阿拉懒神灯
|
调度 Ruby
Sinatra源码学习【下】
Sinatra是一个ruby的轻量级Web框架，这这个框架总共就1000多行代码，非常简洁，值得一读。 一、Sinatra组成 Sinatra的主要实现的代码在base.rb中，主要有以下几个部分: Request:继承于Rack::Request，用于描述一个请求，通过这个类可以很方便获取到请求
阿拉懒神灯
121 0
阿拉懒神灯
|
缓存 中间件 Ruby
Sinatra源码学习【上】
Sinatra是一个ruby的轻量级Web框架，这这个框架总共就1000多行代码，非常简洁，值得一读。 一、Sinatra组成 Sinatra的主要实现的代码在base.rb中，主要有以下几个部分: Request:继承于Rack::Request，用于描述一个请求，通过这个类可以很方便获取到请求
阿拉懒神灯
244 0
冴羽
|
前端开发 JavaScript API
underscore 的源码该如何阅读？
别名：《underscore 系列 8 篇正式完结！》
冴羽
111 0
underscore 的源码该如何阅读？