seajs1.3.0 소스 코드 분석 모듈 종속성 순서대로 loading_javascript 기술

이것은 seajs 로더의 핵심 부분입니다. 일부 IE 호환 부분은 아직 명확하지 않습니다. 가장 중요한 것은 각 모듈이 순서대로 로드되는 방식과 CMD 사양을 이해하는 것입니다.

코드가 좀 길므로 인내심을 갖고 읽어야 합니다.

코드 복사 코드는 다음과 같습니다.

/**
* 로더의 핵심
*/
;(function(seajs, util, config) {
//모듈 캐시
var cashedModules = {}
//인터페이스 수정 캐시
var 캐시된Modifiers = {}
// 컴파일 대기열
var compileStack = []
// 모듈 상태
var STATUS = {
'FETCHING': 1, // 모듈 파일을 가져오는 중입니다.
'FETCHED': 2, // 모듈 파일을 가져오는 중입니다.
'SAVED': 3, // 모듈 정보를 가져왔습니다. 정보가 저장되었습니다
'READY': 4, // 모든 종속성과 자체가 컴파일될 준비가 되었습니다.
'COMPILING': 5, // 모듈이 지금 컴파일 중입니다.
'COMPILED': 6 // 모듈이 컴파일되었으며 module.exports를 사용할 수 있습니다.
}


function Module(uri, status) {
this.uri = uri
this.status = status || 0

// 저장 시 this.id가 설정됩니다.
// this.dependent 저장 시 설정
/ / 저장 시 this.factory 설정
// 컴파일 시 this.exports 설정
// 컴파일 시 this.parent 설정
// this.require 설정 컴파일 시
}


Module.prototype._use = function(ids, callback) {
//배열로 변환, 통합 작업
util.isString(ids) && ( ids = [ids])
// 모듈 시스템 내부의 경로 확인 메커니즘을 사용하여 모듈 경로를 확인하고 반환합니다.
var uris =solve(ids, this.uri)

this._load (uris, function() {
// 컴파일하기 전에 모듈에 도입된 preload 파일을 로드합니다.
// 컴파일하기 전에 preload를 다시 호출하여 모듈을 프리로드합니다
// seajs.config는 언제든지 호출할 수 있으므로 코드 실행 중 사전 로드 모듈을 구성하는 데 걸리는 시간
preload(function() {
// 각 모듈을 컴파일하고 각 모듈의 내보내기를 콜백 함수에 매개변수로 전달합니다.
var args = util.map(uris , function(uri) {
return uri ? cashedModules[uri]._compile() : null
})

if (callback) {
// null은 콜백에서 이 포인터를 만듭니다. 함수 창
callback.apply(null, args)
}
})
})
}

// 기본 모듈은 종속 모듈(하위 모듈이라고 함)을 로드하고 콜백 함수 실행
Module.prototype._load = function(uris, callback) {
// uris 배열 필터링
// 사례 1: 모듈이 캐시에 없으면 해당 uri를 반환합니다. 🎜>// 사례 2: 모듈이 캐시에 있지만 상태가 < STATUS.READY(즉, 컴파일할 준비가 되지 않음)
var unLoadedUris = util.filter(uris, function(uri) {
return uri && (!cachedModules[uri] ||
cachedModules[uri].status < STATUS.READY)
})

var length = unLoadedUris.length
// 길이가 다음과 같은 경우 0이면 종속성이 0이거나 다운로드되었음을 의미합니다. 그런 다음 콜백 컴파일 작업을 수행합니다.
if (length === 0) {
callback()
return
}

var stay = length

for ( var i = 0; i < length; i ) {
// onFetched 함수에 대한 컨텍스트 제공
(function(uri) {
// 모듈 객체 생성
var module = cashedModules[uri] ||
(cachedModules[uri] = new Module(uri, STATUS.FETCHING))
//모듈이 다운로드된 경우 그런 다음 onFetched를 실행하고, 그렇지 않으면 가져오기 작업을 실행합니다(요청 모듈)
module.status >= STATUS.FETCHED ? onFetched() : fetch(uri, onFetched)

function onFetched() {
// 대응하지 않는 경우에는 cashedModules[uri]가 변경됩니다.
module = cashedModules[uri]
// 모듈 상태가 SAVED이면 해당 모듈의 종속성이 결정된 후 종속 모듈을 다운로드합니다.
if (module.status >= STATUS.SAVED) {
// 모듈 정보에서 종속 모듈 목록을 가져와서 순환 종속성 처리
var deps = getPureDependency(module)
// If 종속성이 존재하면
if (deps.length) {
Module.prototype._load(deps, function() {
cb(module)
})
}
/ 다운로드를 계속하세요. / 그렇지 않으면 cb를 직접 실행합니다.
else {
cb(module)
}
}
// 404 또는 모듈이 아닌 경우 가져오기에 실패했을 수 있습니다.
// 이러한 경우에는 cb 함수를 직접 호출하면 됩니다.
// 404나 모듈 불규칙(코드 오류) 등 다운로드 모듈이 성공하지 못하는 경우 모듈 상태가 가져오기 또는 가져오기일 수 있습니다
// 이때 , 콜백 함수가 직접 실행됩니다. 모듈을 컴파일할 때 모듈은 null
else {
cb()
}
}

})(unLoadedUris[i ])
}

function cb(module) {
// 모듈 상태를 READY로 변경합니다. 유지가 0이면 모듈 종속성을 다운로드한 후 콜백을 실행한다는 의미입니다.
(모듈 || {}).status < STATUS.READY && (module.status = STATUS.READY )
--remain === 0 && 콜백()
}
}


Module.prototype._compile = function() {
var module = this
// 모듈이 컴파일되었으면 module.exports를 직접 반환
if (module.status == = STATUS.COMPILED) {
module.exports 반환
}

// 다음 경우에는 null을 반환합니다.
// 1. 모듈 파일이 404입니다.
// 2. 모듈 파일이 유효한 모듈 형식으로 작성되지 않았습니다.
// 3 . 기타 오류 사례
// 이 경우 null이 직접 반환됩니다.
if (module.status < STATUS.SAVED && !hasModifiers(module)) {
return null
}
// 모듈 상태를 COMPILING으로 변경하여 모듈이 컴파일 중임을 나타냅니다.
module.status = STATUS.COMPILING

// 모듈에서 내부적으로 사용되며, 다른 모듈에서 제공하는 정보를 얻는 데 사용되는 메서드( 서브모듈 호출) 인터페이스, 동기 동작
function require(id) {
// id에 따라 모듈 경로 확인
var uri =solve(id, module .uri)
// 모듈 캐시에서 모듈 가져오기(여기서 하위 모듈은 실제로 기본 모듈의 종속성으로 다운로드되었습니다.)
var child = 캐시된Modules[uri]

/ / uri가 유효하지 않은 경우 null을 반환합니다.
// child가 비어 있으면 매개변수 채우기가 올바르지 않고 uri가 올바르지 않다는 의미일 뿐입니다. 그러면 null이 직접 반환됩니다.
if (!child) {
return null
}

// 순환 호출을 방지합니다.
// 하위 모듈의 상태가 STATUS.COMPILING인 경우 순환 문제로 인해 모듈이 반복적으로 컴파일되는 것을 방지하기 위해 child.exports를 직접 반환합니다. 종속성
if (child.status === STATUS.COMPILING) {
return child.exports
}
// 초기화 중에 현재 모듈을 호출하는 모듈을 가리킵니다. 이 속성에 따라 모듈이 초기화될 때 Call Stack을 얻을 수 있습니다.
child.parent = module
// 컴파일된 자식의 module.exports
return child._compile()
}
// 모듈을 비동기적으로 로드하고 로드가 완료된 후 지정된 콜백을 실행하기 위해 모듈에서 내부적으로 사용됩니다.
require.async = function(ids, callback) {
module._use(ids, callback)
}
// 모듈 시스템 내부의 경로 확인 메커니즘을 사용하여 모듈 경로를 구문 분석하고 반환합니다. . 이 함수는 모듈을 로드하지 않고 확인된 절대 경로만 반환합니다.
require.resolve = function(id) {
returnsolve(id, module.uri)
}
// 이 속성을 통해 모듈 시스템에서 로드한 모든 모듈을 볼 수 있습니다.
// 어떤 경우에는 모듈을 다시 로드해야 하는 경우 모듈의 uri를 가져온 다음 delete require.cache[uri]를 사용하여 해당 정보를 삭제할 수 있습니다. 다음에 사용할 때 다시 획득하게 됩니다.
require.cache = 캐시된 모듈

// require는 다른 모듈에서 제공하는 인터페이스를 얻는 데 사용되는 메서드입니다.
module.require = require
//exports는 외부 세계에 모듈 인터페이스를 제공하는 데 사용되는 객체입니다.
module.exports = {}
var Factory = module.factory

// Factory가 함수인 경우 모듈의 구성 방법을 나타냅니다. 이 메소드를 실행하면 모듈에서 제공하는 인터페이스를 얻을 수 있습니다.
if (util.isFunction(factory)) {
compileStack.push(module)
runInModuleContext(factory, module)
compileStack.pop()
}
// 공장은 객체, 문자열 및 기타 비함수 유형이 사용되는 경우 모듈의 인터페이스는 객체, 문자열 및 기타 값입니다.
// 예: Define({ "foo": "bar" });
// 예: Define('나는 템플릿입니다. 내 이름은 {{name}}입니다.'); 🎜> else if (factory !== undefine) {
module.exports = Factory
}

// 모듈 상태를 COMPILED로 변경하여 모듈이 컴파일되었음을 나타냅니다.
module .status = STATUS.COMPILED
// seajs.modify()
execModifiers(module)
return module.exports
}


Module을 통해 모듈 인터페이스 수정을 실행합니다. _define = function(id , deps, Factory) {
var argsLength =args.length
//

에 전달된 매개변수 개수에 따라 매개변수 매칭을 수행합니다.// 정의(공장)
// 매개변수 1개 Case:
// id: 정의되지 않음
// deps: 정의되지 않음 (종속 모듈 목록은 일반 규칙에 따라 나중에 제거됩니다.)
// Factory: function
if (argsLength === 1) {
factory = id
id = unundefined
}
// 정의(id || deps, Factory)
// 두 매개변수의 경우:

else if (argsLength === 2) {
// 기본값: 정의(id, 공장)
// id : '...'
// deps : 정의되지 않음
// Factory : function
factory = deps
deps = undefine

// 정의(deps, Factory)
// 첫 번째 매개변수가 배열인 경우: Define(deps, Factory )
// id : 정의되지 않음
// deps : [...]
// Factory : function
if (util.isArray(id)) {
deps = id
id = 정의되지 않음
}
}

// 종속성을 구문 분석합니다.
// deps가 배열이 아닌 경우(즉, deps가 값을 지정하지 않는 경우) 종속성을 구문 분석합니다. 정규식을 통해
if (!util.isArray( deps) && util.isFunction(factory)) {
deps = util.parseDependacies(factory.toString())
}

/ / 해당 모듈에 전달될 메타 정보
var me = { id: id, dependency: deps, Factory: Factory } 개체
var 파생Uri

// 익명 모듈의 경우 IE6-9에서 uri를 가져옵니다.
/ / IE6-9의 경우 대화형 스크립트를 통해 모듈의 uri를 가져옵니다.
if (document.attachEvent) {
// 현재 스크립트
// 현재 스크립트 가져오기
var script = util.getCurrentScript()
if (script) {
// 키와 일치하도록 현재 스크립트의 URL을 구문 분석 해제합니다. 모듈 캐시에서
derivedUri = util.unParseMap(util.getScriptAbsoluteSrc(script) )
}

if (!derivedUri) {
util.log('대화형에서 URI를 파생하지 못했습니다. 스크립트:',
factory.toString(), 'warn')

// 참고: 위의 ID 파생 메서드가 실패하면
// onload 이벤트를 사용하도록 대체됩니다.
}
}

// 특정 모듈에 대한 uri를 직접 가져옵니다.
// ID가 제공되면 경로가 ID에 따라 구문 분석됩니다. >// 분명히 id가 지정되지 않은 경우:
// IE가 아닌 브라우저의 경우 정의되지 않음을 반환합니다(derivedUri는 비어 있음)
// IE 브라우저의 경우 CurrentScript의 src가 반환됩니다.
// If id가 지정됨:
// seajs로 구문 분석된 경로 url이 반환됩니다.
varsolvedUri = id ? {
// IE의 경우:
// 패키지의 첫 번째 모듈이 캐시된 모듈[derivedUri]
// 자체가 아닌 경우 발견 시 올바른 모듈에 할당해야 합니다.
( 해결된Uri === 파생된Uri) {
var refModule = 캐시된모듈[derivedUri]
if (refModule && refModule.realUri &&
refModule.status === STATUS.SAVED) {
cachedModules[derivedUri] = null
}
}
//스토리지 모듈 정보
var module = save(resolvedUri, Meta)

// IE의 경우:
// 캐시된 모듈[derivedUrl]
if (derivedUri) {
/ / 캐시 모듈[derivedUri]은 콤보 케이스에서 정의되지 않을 수 있습니다.
if ((cachedModules[derivedUri] || {}).status === STATUS.FETCHING) {
cachedModules[derivedUri] = module
module .realUri = 파생Uri
}
}
else {
// 첫 번째 모듈을 firstModuleInPackage에 저장
firstModuleInPackage || (firstModuleInPackage = module)
}
}
// uri가 없으면 모듈 정보는 onload 콜백에 저장되며, 여기에는 클로저가 있습니다.
else {
// onload 이벤트에 "memoizing" 작업을 위한 정보를 저장합니다.
/ / 이때 uri를 알 수 없기 때문에 anonymousModuleMeta에 메타정보를 임시 저장하고, onload 콜백에서 모듈 저장 작업을 수행합니다
익명ModuleMeta = 메타
}

}

// 컴파일 중인 모듈 가져오기
Module._getCompilingModule = function() {
return compileStack[compileStack.length - 1]
}

// seajs.cache에서 합계를 빠르게 확인합니다. 로드된 모듈 인터페이스를 가져옵니다. 반환 값은 module.exports 배열입니다.
// 선택기는 문자열과 정규식을 지원합니다.
모듈 ._find = function(selector) {
var match = []

util.forEach(util.keys(cachedModules), function(uri) {
if (util.isString(selector) && uri.indexOf(selector) > -1 ||
util.isRegExp( selector) && selector.test(uri)) {
var module = cashedModules[uri]
module.exports && match.push (module.exports)
}
})

일치 항목 반환
}

// 모듈 인터페이스 수정
Module._modify = function(id, modifier) ​​​​{
var uri = 해결(id)
var module = 캐시된Modules[uri]
// 모듈이 존재하고 COMPILED 상태인 경우 인터페이스 수정 작업을 수행합니다.
if (module && module.status === STATUS.COMPILED) {
runInModuleContext(modifier, module)
}
// 그렇지 않으면 수정된 인터페이스 캐시에 넣습니다.
else {
cachedModifiers[uri] || (cachedModifiers[uri] = [])
cachedModifiers[uri].push(modifier) ​​​​
}

return seajs
}


// 플러그인 개발자용
Module.STATUS = STATUS
Module._resolve = util.id2Uri
Module._fetch = util.fetch
Module.cache = 캐시된Modules


// 헬퍼
// -------
// 모듈 목록 downloaded
var fetchingList = {}
//다운로드된 모듈 목록
var fetchedList = {}
// 콜백 함수 목록
var callbackList = {}
//익명 모듈 메타 정보
var anonymousModuleMeta = null
var firstModuleInPackage = null
// 순환 종속성 스택
var CircularCheckStack = []

// 일괄 구문 분석된 모듈의 경로
functionsolv(ids) , refUri) {
if (util.isString(ids)) {
return Module._resolve(ids, refUri)
}

return util.map(ids, function(id) {
returnsolve( id, refUri)
})
}

function fetch(uri, callback) {
// 가져올 때 먼저 맵 규칙에 따라 uri를 변환합니다.
var requestUri = util.parseMap(uri)
// fethedList(다운로드한 모듈 목록)에서 검색하고, 있는 경우 직접 반환하고 콜백 함수를 실행합니다.
// TODO: 이 모듈이 fetchedList에 존재하는 이유는 무엇입니까? 이 단계에서는?
if (fetchedList[requestUri]) {
// test/issues/debug-using-map 참조
cachedModules[uri] = 캐시된Modules[requestUri]
callback()
return
}
// fetchingList(다운로드 중인 모듈 목록)에서 검색합니다. 있는 경우 목록에 콜백 함수를 추가하고 바로 반환합니다.
if (fetchingList[requestUri]) {
callbackList[requestUri].push(callback)
return
}
// 이 단계에 이르면 처음으로 모듈을 요청했다는 의미입니다.
// 그런 다음 모듈을 삽입합니다. fetchingList 정보에서 모듈이 이미 다운로드 목록에 있음을 나타내며 모듈에 해당하는 콜백 함수 목록을 초기화합니다.
fetchingList[requestUri] = true
callbackList[requestUri] = [callback]

// 가져옵니다
// 모듈 가져오기, 즉 요청 시작
Module._fetch(
requestUri,

function() {
// 모듈의 fetchedList에 있는 정보는 모듈이 다운로드되었습니다
fetchedList[requestUri] = true

// 모듈 상태 업데이트
var module = 캐시된Modules[uri]
// 이때 상태는 STATUS.SAVED일 수 있습니다. 이전에는 _define
if (module.status === STATUS.FETCHING) {
module.status = STATUS.FETCHED
}
// 익명 모듈 메타데이터를 저장합니다
// 익명 모듈이기 때문에 (이때 클로저를 통해 uri 를 얻어 여기에 모듈 정보가 저장됩니다)
// 그리고 anonymousModuleMeta 를 비워둡니다
if (anonymousModuleMeta) {
save(uri, anonymousModuleMeta)
anonymousModuleMeta = null
}

// 패키지의 첫 번째 모듈을 캐시된 모듈[uri]에 할당합니다.
// 참조: 테스트/문제/비대응
if ( firstModuleInPackage && module.status === STATUS.FETCHED) {
cachedModules[uri] = firstModuleInPackage
firstModuleInPackage.realUri = uri
}
firstModuleInPackage = null

// 지우기
// 모듈을 가져오고 저장했으므로 fetchingList에서 모듈 정보를 지웁니다.
if (fetchingList[requestUri]) {
delete fetchingList[requestUri]
}

// callbackList 호출
// 콜백 함수를 순서대로 호출하고 콜백 함수 목록을 지웁니다.
if (callbackList[requestUri]) {
util.forEach(callbackList [requestUri], function(fn) {
fn()
})
delete callbackList[requestUri]
}

},

config.charset
)
}

function save(uri,meta) {
var module = 캐시된Modules[uri] || (cachedModules[uri] = new Module(uri))

// 이미 저장된 모듈을 재정의하지 마세요
// 상태에는 두 가지 상태가 있을 수 있습니다:
// STATUS.FETCHING, 정의(지정된 ID)에서 호출, 모듈 정보 저장
// STATUS. onload 콜백 함수에서 호출되는 FETCHED는 모듈 정보를 저장합니다
if (module.status < STATUS.SAVED) {
// 익명 모듈 ID를 해당 URI와 동일하게 합니다
// 익명 모듈(즉, , ID가 지정되지 않음), 해당 URI를 ID로 사용
module.id = Meta.id || uri
// 종속성(배열)에서 절대 경로를 구문 분석하여 모듈 정보에 저장합니다
module.dependent = 해결(
util.filter(meta .dependent || [], function(dep) {
return !!dep
}), uri)
// 팩토리 저장(모듈 실행될 코드(객체 또는 문자열 등일 수도 있음)
module.factory = Meta.factory

// 모듈 상태 업데이트
// 업데이트 모듈 상태는 SAVED입니다. (현재는 종속성만 있고 아직 모두 다운로드되지는 않았습니다(즉, 아직 준비되지 않음))
module.status = STATUS.SAVED
}

모듈 반환
}

// 모듈 컨텍스트에 따라 모듈 코드 실행
function runInModuleContext(fn, module) {
// 모듈과 모듈 자체에 관련된 두 개의 매개변수를 전달합니다.
// 내보내기는 다음과 같습니다. 인터페이스를 노출하는 데 사용됨
// require는 종속 모듈을 가져오는 데 사용됨(동기화)(컴파일)
var ret = fn(module.require, module.exports, module)
// 반환 값 노출 지원 다음과 같은 인터페이스 형식:
// return {
// fn1 : xx
// ,fn2 : xx
// ...
// }
if (ret !== 정의되지 않음) {
module.exports = ret
}
}
// 모듈에 인터페이스 수정이 있는지 확인
function hasModifiers(module) {
return !!cachedModifiers [module.realUri ||]
}
// 모듈 인터페이스 수정
function execModifiers(module) {
var uri = module.realUri
var modifiers = 캐시된Modifiers[uri]
// 내부 변수인 cachedModifiers는 seajs.modify 메소드를 통해 사용자가 정의한 값을 저장하는 데 사용됩니다. 수정 지점
//수정에 의해 uri가 변경되었는지 확인
if (modifiers) {
// 수정 지점에서 균일하게 팩토리를 실행하고 수정된 module.exports를 반환합니다.
util.forEach( modifiers, function(modifier) ​​​​{
runInModuleContext(modifier, module )
})
// 다시 실행되지 않도록 수정 메소드로 정의된 수정 지점을 삭제하세요.
delete cashedModifiers[uri]
}
}

//순수한 종속성을 가져오고 순환 종속성이 없는 종속성 배열을 가져옵니다.
function getPureDependency(module) {
var uri = module.uri
// 각 종속성에 대해 항목을 필터링하고 제거합니다. 순환 종속성을 형성할 수 있는 항목은 경고 로그를 인쇄합니다.
return util.filter(module.dependent, function(dep) {
// 먼저 확인된 모듈의 uri를 순환 종속성 확인 스택에 넣습니다. , 후속 검사에서는
circularCheckStack = [uri]
를 사용합니다.//다음으로, 모듈 uri가 종속 모듈에 대한 순환 종속성을 가지고 있는지 확인합니다.
var isCircular = isCircularWaiting(cachedModules[dep ])
(isCircular) {
// 순환인 경우 uri를 순환 종속성 검사 스택에 넣습니다.
circularCheckStack.push(uri)
// 순환 경고 로그를 인쇄합니다
printCircularLog(circularCheckStack)
}

return !isCircular
})
}

function isCircularWaiting(module) {
// 종속 모듈이 없으면 false를 반환합니다. , 현재 종속 모듈의 종속성을 얻을 수 없기 때문에 여기에서는 판단을 내릴 수 없습니다
// 또는 모듈의 상태 값이 저장된 것과 같으면 false도 반환됩니다. 이미 가지고 있는 모듈의 정보를 나타냅니다.
// 그래서 순환 의존성이 형성되더라도 메인 모듈이 필요할 때 정상적으로 컴파일이 가능하고 메인 모듈 인터페이스가 반환됩니다. nodejs는 정의되지 않은 상태를 반환할 것 같습니다)
if (!module || module.status !== STATUS.SAVED) {
return false
}
// 위 상황이 아닌 경우 종속 모듈의 URI를 순환 종속성 검사 스택에 넣으면 후속 검사에서는
circularCheckStack.push(module.uri)
// 종속 모듈의 종속 모듈을 다시 가져옵니다.
var deps = module.dependent

if (deps.length) {
// 루프 종속성 검사 스택을 통해 순환 종속성이 있는지 확인합니다(여기서는 종속성 모듈 검사의 첫 번째 계층, 기본 모듈과의 순환 종속성이 있습니다). module)
if (isOverlap(deps, CircularCheckStack)) {
return true
}
// 위의 상황이 존재하지 않는 경우 종속 모듈의 종속 모듈을 추가로 확인하여 다음과 같은지 확인합니다. 순환 종속성 검사 스택
에서 uri의 모듈에 순환 종속성이 있습니다.// 이 경우 재귀적이고 순환적입니다. 종속성 검사 스택은 현재 모듈이 메인 모듈인 체인을 확인하는 것과 같습니다. 메인 모듈의 모듈... 종속성이 있는지 확인하기 위해 상단의 메인 모듈까지
for (var i = 0; i < deps.length; i ) {
if (isCircularWaiting(cachedModules[ deps[i]])) {
return true
}
}
}
// 그렇지 않은 경우 순환 종속성이 있는 경우 푸시된 모듈 URI를 팝업합니다. before 및 return false
circularCheckStack.pop()
return false
}
// 순환 경고 로그 인쇄
function printCircularLog(stack, type) {
util.log( '순환 종속성 발견:', stack.join(' --> '), type)
}
//두 배열이 중복되었는지 확인
함수의 값 isOverlap(arrA, arrB) {
var arrC = arrA.concat(arrB)
return arrC.length > util.unique(arrC).length
}
/ / 구성 파일에서 필요한 모듈이 있는지 읽습니다. 미리 로드하세요
// 미리 로드된 모듈이 있는 경우 먼저 미리 로드된 모듈을 빈 상태로 설정하고(다음에 다시 로드할 필요가 없도록) 미리 로드된 모듈을 로드하고 다음과 같은 경우 콜백을 실행합니다. 그렇지 않은 경우 순차적으로 실행
function preload(callback) {
var preloadMods = config.preload.slice()
config.preload = []
preloadMods.length ? globalModule._use(preloadMods, callback ) : callback()
}


// 공개 API
// 외부에 노출되는 API
// ----------
// 전역 모듈은 페이지 모듈로 간주할 수 있습니다. 페이지의 js 및 css 파일은 이를 통해 로드됩니다.
// 모듈의 초기 상태는 COMPILED이고 uri는 페이지의 uri입니다. 🎜>var globalModule = new Module(util .pageUri, STATUS.COMPILED)

// 페이지 js, css 파일 로더
seajs.use = function(ids, callback) {
// 로드 다른 모든 모듈보다 먼저 모듈을 미리 로드합니다.
preload(function() {
globalModule._use(ids, callback)
})

// 체인
return seajs
}


// 일반 사용자용
// 일반 사용자용
seajs.define = Module._define
seajs.cache = Module. 캐시
seajs.find = Module._find
seajs.modify = Module._modify


// 플러그인 개발자용
// 개발자용
seajs.pluginSDK = {
모듈: 모듈,
util: util,
config: config
}

})(seajs, seajs._util, seajs._config)