Seajs源码详解分析

<!-- 首先在页面中引入sea.js，也可以使用cdn资源 -->
<script type="text/javascript" src="./sea.js"></script>
<script>
// 设置一些参数
seajs.config({
 debug: true, // debug为false时，在模块加载完毕后会移除head中的script标签
 base: './js/', // 通过路径加载其他模块的默认根目录
 alias: { // 别名
 jquery: 'https://cdn.bootcss.com/jquery/3.2.1/jquery'
 }
})

seajs.use('main', function(main) {
 alert(main)
})
</script>

//main.js
define(function (require, exports, module) {
 // require('jquery')
 // var $ = window.$

 module.exports = 'main-module'
})

(function (global, undefined) {
 if (global.seajs) {
 return
 }
 var data = seajs.data = {}
 
 seajs.config = function (configdata) {
 for (var key in configdata) {
  var curr = configdata[key] // 获取当前配置
  var prev = data[key] // 获取之前的配置
  if (prev && isobject(prev)) { // 如果之前已经设置过，且为一个对象
  for (var k in curr) {
   prev[k] = curr[k] // 用新值覆盖旧值，旧值保留不变
  }
  }
  else {
  // 如果之前的值为数组，进行concat
  if (isarray(prev)) {
   curr = prev.concat(curr)
  }
  // 确保 base 为一个路径
  else if (key === "base") {
   // 必须已 "/" 结尾
   if (curr.slice(-1) !== "/") {
   curr += "/"
   }
   curr = addbase(curr) // 转换为绝对路径
  }

  // set config
  data[key] = curr 
  }
 }
 }
})(this);

// requirejs
require(['main'], function (main) {
 console.log(main)
});

seajs.use = function(ids, callback) {
 module.use(ids, callback, data.cwd + "_use_" + cid())
 return seajs
}

// 该方法用来加载一个匿名模块
module.use = function (ids, callback, uri) { //如果是通过seajs.use调用，uri是自动生成的
 var mod = module.get(
 uri,
 isarray(ids) ? ids : [ids] // 这里会将依赖模块转成数组
 )

 mod._entry.push(mod) // 表示当前模块的入口为本身，后面还会把这个值传入他的依赖模块
 mod.history = {}
 mod.remain = 1 // 这个值后面会用来标识依赖模块是否已经全部加载完毕

 mod.callback = function() { //设置模块加载完毕的回调，这一部分很重要，尤其是exec方法
 var exports = []
 var uris = mod.resolve()
 for (var i = 0, len = uris.length; i < len; i++) {
  exports[i] = cachedmods[uris[i]].exec()
 }
 if (callback) {
  callback.apply(global, exports) //执行回调
 }
 }

 mod.load()
}

var cachedmods = seajs.cache = {} // 模块的缓存对象
module.get = function(uri, deps) {
 return cachedmods[uri] || (cachedmods[uri] = new module(uri, deps))
}
function module(uri, deps) {
 this.uri = uri
 this.dependencies = deps || []
 this.deps = {} // ref the dependence modules
 this.status = 0
 this._entry = []
}

// 所有依赖加载完毕后执行 onload
module.prototype.load = function() {
 var mod = this
 mod.status = status.loading // 状态置为模块加载中
 
 // 调用resolve方法，将模块id转为uri。
 // 比如之前的"mian"，会在前面加上我们之前设置的base，然后在后面拼上js后缀
 // 最后变成: "http://qq.com/web/js/main.js"
 var uris = mod.resolve()

 // 遍历所有依赖项的uri，然后进行依赖模块的实例化
 for (var i = 0, len = uris.length; i < len; i++) {
 mod.deps[mod.dependencies[i]] = module.get(uris[i])
 }

 // 将entry传入到所有的依赖模块，这个entry是我们在use方法的时候设置的
 mod.pass()
 
 if (mod._entry.length) {
 mod.onload()
 return
 }

 // 开始进行并行加载
 var requestcache = {}
 var m

 for (i = 0; i < len; i++) {
 m = cachedmods[uris[i]] // 获取之前实例化的模块对象
 m.fetch(requestcache) // 进行fetch
 }

 // 发送请求进行模块的加载
 for (var requesturi in requestcache) {
 if (requestcache.hasownproperty(requesturi)) {
  requestcache[requesturi]() //调用 seajs.request
 }
 }
}

module.prototype.resolve = function() {
 var mod = this
 var ids = mod.dependencies // 取出所有依赖模块的id
 var uris = []
 // 进行遍历操作
 for (var i = 0, len = ids.length; i < len; i++) {
 uris[i] = module.resolve(ids[i], mod.uri) //将模块id转为uri
 }
 return uris
}

module.resolve = function(id, refuri) {
 var emitdata = { id: id, refuri: refuri }
 return seajs.resolve(emitdata.id, refuri) // 调用 id2uri
}

seajs.resolve = id2uri

function id2uri(id, refuri) { // 将id转为uri，转换配置中的一些变量
 if (!id) return ""

 id = parsealias(id)
 id = parsepaths(id)
 id = parsealias(id)
 id = parsevars(id)
 id = parsealias(id)
 id = normalize(id)
 id = parsealias(id)

 var uri = addbase(id, refuri)
 uri = parsealias(uri)
 uri = parsemap(uri)
 return uri
}

function parsealias(id) { //如果有定义alias，将id替换为别名对应的地址
 var alias = data.alias
 return alias && isstring(alias[id]) ? alias[id] : id
}

module.prototype.pass = function() {
 var mod = this
 var len = mod.dependencies.length

 // 遍历入口模块的_entry属性，这个属性一般只有一个值，就是它本身
 // 具体可以回去看use方法 -> mod._entry.push(mod)
 for (var i = 0; i < mod._entry.length; i++) {
 var entry = mod._entry[i] // 获取入口模块
 var count = 0 // 计数器，用于统计未进行加载的模块
 for (var j = 0; j < len; j++) {
  var m = mod.deps[mod.dependencies[j]] //取出依赖的模块
  // 如果模块未加载，并且在entry中未使用，将entry传递给依赖
  if (m.status < status.loaded && !entry.history.hasownproperty(m.uri)) {
  entry.history[m.uri] = true // 在入口模块标识曾经加载过该依赖模块
  count++
  m._entry.push(entry) // 将入口模块存入依赖模块的_entry属性
  }
 }
 // 如果未加载的依赖模块大于0
 if (count > 0) {
  // 这里`count - 1`的原因也可以回去看use方法 -> mod.remain = 1
  // remain的初始值就是1，表示默认就会有一个未加载的模块，所有需要减1
  entry.remain += count - 1
  // 如果有未加载的依赖项，则移除掉入口模块的entry
  mod._entry.shift()
  i--
 }
 }
}

var requestcache = {}
for (i = 0; i < len; i++) {
 m = cachedmods[uris[i]] // 获取之前实例化的模块对象
 m.fetch(requestcache) // 进行fetch
}

module.prototype.fetch = function(requestcache) {
 var mod = this
 var uri = mod.uri

 mod.status = status.fetching
 callbacklist[requesturi] = [mod]

 emit("request", emitdata = { // 设置加载script时的一些数据
 uri: uri,
 requesturi: requesturi,
 onrequest: onrequest,
 charset: isfunction(data.charset) ? data.charset(requesturi) : data.charset,
 crossorigin: isfunction(data.crossorigin) ? data.crossorigin(requesturi) : data.crossorigin
 })

 if (!emitdata.requested) { //发送请求加载js文件
 requestcache[emitdata.requesturi] = sendrequest
 }

 function sendrequest() { // 被request方法，最终会调用 seajs.request
 seajs.request(emitdata.requesturi, emitdata.onrequest, emitdata.charset, emitdata.crossorigin)
 }

 function onrequest(error) { //模块加载完毕的回调
 var m, mods = callbacklist[requesturi]
 delete callbacklist[requesturi]
 // 保存元数据到匿名模块，uri为请求js的uri
 if (anonymousmeta) {
  module.save(uri, anonymousmeta)
  anonymousmeta = null
 }
 while ((m = mods.shift())) {
  // when 404 occurs, the params error will be true
  if(error === true) {
  m.error()
  }
  else {
  m.load()
  }
 }
 }
}

for (var requesturi in requestcache) {
 requestcache[requesturi]() //调用 seajs.request
}

//用来加载js脚本的方法
seajs.request = request

function request(url, callback, charset, crossorigin) {
 var node = doc.createelement("script")
 addonload(node, callback, url)
 node.async = true //异步加载
 node.src = url
 head.appendchild(node)
}

function addonload(node, callback, url) {
 node.onload = onload
 node.onerror = function() {
 emit("error", { uri: url, node: node })
 onload(true)
 }

 function onload(error) {
 node.onload = node.onerror = node.onreadystatechange = null
 // 脚本加载完毕的回调
 callback(error)
 }
}

if (mod._entry.length) {
 mod.onload()
 return
}

module.prototype.onload = function() {
 var mod = this
 mod.status = status.loaded 
 for (var i = 0, len = (mod._entry || []).length; i < len; i++) {
 var entry = mod._entry[i]
 // 每次加载完毕一个依赖模块，remain就-1
 // 直到remain为0，就表示所有依赖模块加载完毕
 if (--entry.remain === 0) {
  // 最后就会调用entry的callback方法
  // 这就是前面为什么要给每个依赖模块存入entry
  entry.callback()
 }
 }
 delete mod._entry
}

mod.callback = function() { //设置模块加载完毕的回调
 var exports = []
 var uris = mod.resolve()

 for (var i = 0, len = uris.length; i < len; i++) {
 // 执行所有依赖模块的exec方法，存入exports数组
 exports[i] = cachedmods[uris[i]].exec()
 }

 if (callback) {
 callback.apply(global, exports) //执行回调
 }

 // 移除一些属性
 delete mod.callback
 delete mod.history
 delete mod.remain
 delete mod._entry
}

module.prototype.exec = function () {
 var mod = this

 mod.status = status.executing

 if (mod._entry && !mod._entry.length) {
 delete mod._entry
 }

 function require(id) {
 var m = mod.deps[id]
 return m.exec()
 }

 var factory = mod.factory

 // 调用define定义的回调
 // 传入commonjs相关三个参数: require, module.exports, module
 var exports = factory.call(mod.exports = {}, require, mod.exports, mod)
 if (exports === undefined) {
 exports = mod.exports //如果函数没有返回值，就取mod.exports
 }
 mod.exports = exports
 mod.status = status.executed

 return mod.exports // 返回模块的exports
}

define(function (require, exports, module) {
 module.exports = 'main-module'
})

global.define = module.define
module.define = function (id, deps, factory) {
 var argslen = arguments.length

 // 参数校准
 if (argslen === 1) {
 factory = id
 id = undefined
 }
 else if (argslen === 2) {
 factory = deps
 if (isarray(id)) {
  deps = id
  id = undefined
 }
 else {
  deps = undefined
 }
 }

 // 如果没有直接传入依赖数组
 // 则从factory中提取所有的依赖模块到dep数组中
 if (!isarray(deps) && isfunction(factory)) {
 deps = typeof parsedependencies === "undefined" ? [] : parsedependencies(factory.tostring())
 }

 var meta = { //模块加载与定义的元数据
 id: id,
 uri: module.resolve(id),
 deps: deps,
 factory: factory
 }

 // 激活define事件, used in nocache plugin, seajs node version etc
 emit("define", meta)

 meta.uri ? module.save(meta.uri, meta) :
 // 在脚本加载完毕的onload事件进行save
 anonymousmeta = meta
 }

function onrequest(error) { //模块加载完毕的回调
...
 // 保存元数据到匿名模块，uri为请求js的uri
 if (anonymousmeta) {
 module.save(uri, anonymousmeta)
 anonymousmeta = null
 }
...
}

// 存储元数据到 cachedmods 中
module.save = function(uri, meta) {
 var mod = module.get(uri)
 
 if (mod.status < status.saved) {
 mod.id = meta.id || uri
 mod.dependencies = meta.deps || []
 mod.factory = meta.factory
 mod.status = status.saved
 }
}