namespace.js Javascript namespace library_javascript tips-JS Tutorial-php.cn

github: https://github.com/hirokidaichi/namespace-js
Define the Namespace object:
var Namespace
Now let’s take a closer look at the definition of the Namespace object, which is a NamespaceDefinition object. This object is a function object (the constructor of the NamespaceDefinition object, if no parameters are given, a main namespace will be generated by default), and there are three attributes, Object, Definition, and Proc. Its values are NamespaceObjectFactory, NamespaceDefinition, and createProcedure function object classes.

Copy code The code is as follows:

 
var createNamespace = function(fqn){ 
return new NamespaceDefinition( 
NamespaceObjectFactory.create(fqn || 'main') 
); 
}; 
merge(createNamespace, { 
'Object' : NamespaceObjectFactory , 
Definition: NamespaceDefinition, 
Proc : createProcedure 
}); 

NamespaceObjectFactory: Generate NamespaceObject object based on fqn.
The NamespaceObjectFactory object has only one create method, and the parameter is the name of the namespace (Fully Qualified Name). This method has a closure environment, which has a cache variable used to cache all generated NamespaceObject objects.
A NamespaceObject object contains three attributes, stash (record the current namespace), fqn (namespace name), proc (createProcedure object). Methods include: enqueue, call, valueof, merge, getStash, getExport

Copy code The code is as follows:

 
var NamespaceObject = function _Private_Class_Of_NamespaceObject(fqn){ 
merge(this, { 
stash: { CURRENT_NAMESPACE : fqn }, 
fqn : fqn, 
proc : createProcedure() 
}); 
}; 
merge(NamespaceObject.prototype, { 
enqueue: function(context) { 
this.proc.next(context); 
}, 
call: function(state,callback) { 
this.proc.call(state, callback); 
}, 
valueOf: function() { 
return "#NamespaceObject<" this.fqn ">"; 
}, 
merge: function(obj) { 
merge(this.stash,obj); 
return this; 
}, 
getStash: function() { 
return this.stash; 
}, 
getExport: function(importName) { 
if (importName === '*') return this.stash; 

var importNames = importName.split(/,/), 
retStash = {}; 
for(var i = 0,l=importNames.length;i104 retStash[ importNames[i] ] = this.stash[ importNames[i] ]; 
} 
return retStash ; 
} 
}); 
var NamespaceObjectFactory = (function() { 
var cache = {}; 
return { 
create :function(fqn ){ 
_assertValidFQN(fqn); 
return (cache[fqn] || (cache[fqn] = new NamespaceObject(fqn))); 
} 
}; 
})(); 

NamespaceDefinition:
This object includes 5 properties, namespaceObject, requires, useList, stash, defineCallback. And provides related methods: use, _mergeStashWithNS, loadImport, define, getStash, valueOf, apply
This object is the core of the namespace library, which provides all required methods.
During initialization, add a function object to the steps queue of NamespaceObject's proc, and the function will call the apply method.

Copy code The code is as follows:

 
var NamespaceDefinition = function _Private_Class_Of_NamespaceDefinition(nsObj) { 
merge(this, { 
namespaceObject: nsObj, 
requires : [], 
useList : [], 
stash : {}, 
defineCallback : undefined 
}); 
var _self = this; 
nsObj.enqueue(function($c){ _self.apply($c); }); 
}; 
merge(NamespaceDefinition.prototype, { 
use: function(syntax){ 
this.useList.push(syntax); 
var splitted = syntax.split(/s /); 
var fqn = splitted[0]; 
var importName = splitted[1]; 
_assertValidFQN(fqn); 
this.requires.push(function($c){ 
var context = this; 
var require = NamespaceObjectFactory.create(fqn); 
require.call(this,function(state){ 
context.loadImport(require,importName); 
$c(); 
}); 
}); 
return this; 
}, 
_mergeStashWithNS: function(nsObj){ 
var nsList = nsObj.fqn.split(/./); 
var current = this.getStash(); 

for(var i = 0,l=nsList.length;i152 if( !current[nsList[i]] ) current[nsList[i]] = {}; 
current = current[nsList[i]]; 
} 

var lastLeaf = nsList[nsList.length-1]; 
current[lastLeaf] = merge(current[lastLeaf] || {}, nsObj.getStash()); 
}, 
loadImport: function(nsObj,importName){ 
if( importName ){ 
merge( this.stash, nsObj.getExport(importName) ); 
}else{ 
this._mergeStashWithNS( nsObj ); 
} 
}, 
define: function(callback){ 
var nsDef = this, nsObj = this.namespaceObject; 
this.defineCallback = function($c) { 
var ns = { 
provide : function(obj){ 
nsObj.merge(obj); 
$c(); 
} 
}; 
merge(ns, nsDef.getStash()); 
merge(ns, nsObj.getStash()); 
callback(ns); 
}; 
}, 
getStash: function(){ 
return this.stash; 
}, 
valueOf: function(){ 
return "#NamespaceDefinition<" this.namespaceObject "> uses :"   this.useList.join(','); 
}, 
apply: function(callback){ 
var nsDef = this; 
createProcedure(nsDef.requires) 
.next(nsDef.defineCallback) 
.call(nsDef,function(){ 
callback( nsDef.getStash() ); 
}); 
} 
}); 

createProcedure：该对象是一个函数对象，返回Procedure对象的next方法的结果。
Procedure：
Procedure对象有三个属性：state，steps，_status（默认为init）。提供一下几种方法：next，isRunnig，enqueue，dequeue，call，_invoke。

复制代码代码如下:

 
var Namespace = (function(){ 
/* utility */ 
var merge = function(target, source){ // Copy all the properties of source to target Go and return target object 4 for(var p in source) 
if(source.hasOwnProperty( p )) target[p] = source[p]; 
return target; 
}; 
var _assertValidFQN = function(fqn){ // Verify the validity of the namespace name, which must be lowercase alphanumeric, underscore and dot 
if(!(/^[a-z0-9_.] /) .test(fqn)) throw('invalid namespace'); 
}; 

var Procedure = function _Private_Class_Of_Proc(){ 
merge(this, { 
state : {}, // Status 
steps : [], // Array to store status 
_status: 'init' 
}); 
}; 
merge( Procedure.prototype, { 
next: function(state){ // If state has a value, store it at the end of the steps queue, and then return this 
if(state) this.enqueue(state); 
return this; 
}, 
isRunning: function(){ // Determine whether it is running status
return (this._status === 'running'); 
}, 
enqueue: function(state){ // Here, the array steps is actually used to simulate the queue, and enqueue is put into the queue from the end of the queue 
this.steps.push(state); 
} , 
dequeue: function(){ // dequeue means dequeuing from the opposite end 
return this.steps.shift(); 
}, 
call: function(initialState,callback) { // 
if( this.isRunning() ) throw("do not run twice"); 

this.state = initialState || {}; // Save the current state (NamespaceDefinition Object) 
this.enqueue(function($c){ // Function is queued steps 
$c(); // Execute the function passed in 
if(callback)callback(this) ; // If there is a callback function, execute the callback function 
}); 
this._status = 'running'; // Set the status to running 
this._invoke(); // Call _invoke 
}, 
_invoke: function(){ 
var _self = this; 
var step = _self.dequeue(); // Object dequeue (FIFO) 
if( !step ){ 
_self._status = 'finished'; // If the queue is empty, set the status to finished 
return; 
} // When step is an array Don’t follow this path
if( step.call ) { // If the object is a function object, execute the call method, and specify the internal this as _self.state, and continue calling_ in the callback function invoke 
return step.call( _self.state,function _cont(state){ 
if( state ) _self.state = state; 
_self._invoke(); 
}) ; 
} 
var finishedProcess = 0; 
if( step.length === 0 ) _self._invoke(); // If the length of the array is 0, call _invoke 
for(var i =0,l=step.length;i60 step[i].call(_self.state,function _joinWait(){ 
finishedProcess ; 
if( finishedProcess == l ){ 
_self. _invoke(); 
} 
}); 
} 
} 
}); 

var createProcedure = function(state) { 
return new Procedure().next(state); 
}; 

var NamespaceObject = function _Private_Class_Of_NamespaceObject(fqn){ 
merge(this, { 
stash: { CURRENT_NAMESPACE : fqn }, 
fqn : fqn, 
proc : createProcedure() 
}); 
}; 
merge(NamespaceObject.prototype, { 
enqueue: function(context) { 
this.proc.next(context); 
}, 
call: function(state,callback) { 
this.proc. call(state, callback); 
}, 
valueOf: function() { 
return "#NamespaceObject<" this.fqn ">"; 
}, 
merge: function(obj) { 
merge(this.stash,obj); 
return this; 
}, 
getStash: function() { 
return this .stash; 
}, 
getExport: function(importName) { 
if (importName === '*') return this.stash; 

var importNames = importName.split(/,/), 
retStash = {}; 
for(var i = 0,l=importNames.length;i104 retStash[ importNames[ i] ] = this.stash[ importNames[i] ]; 
} 
return retStash; 
} 
}); 
var NamespaceObjectFactory = (function() { 
var cache = {}; 
return { 
create :function(fqn){ 
_assertValidFQN(fqn); 
return (cache[fqn] || (cache [fqn] = new NamespaceObject(fqn))); 
} 
}; 
})(); 

var NamespaceDefinition = function _Private_Class_Of_NamespaceDefinition(nsObj) { 
merge(this, { 
namespaceObject: nsObj, 
requires : [], 
useList : [], 
stash : {}, 
defineCallback : undefined 
}); 
var _self = this; 
nsObj.enqueue(function($c){ _self.apply($c); }); 
}; 
merge(NamespaceDefinition.prototype, { 
use: function(syntax){ // Use namespace 
this.useList.push(syntax); // The namespace string is stored in the array useList 
var splitted = syntax.split(/s /); // Namespace and its objects are separated by spaces 
var fqn = splitted[0]; // Get namespace 
var importName = splitted [1]; // Get the object in namespace 
_assertValidFQN(fqn); 
this.requires.push(function($c){ // Put a function into the requires array 
var context = this; 
var require = NamespaceObjectFactory.create(fqn); // Get the specified NamespaceObject object. Previously generated objects can be obtained directly from the cache 
require.call(this,function(state ){ // Call the call method of the NamespaceObject object 
context.loadImport(require,importName); 
$c(); 
}); 
}); 
return this; 
}, 
_mergeStashWithNS: function(nsObj){ 
var nsList = nsObj.fqn.split(/./); 
var current = this.getStash() ; 

for(var i = 0,l=nsList.length;i152 if( !current[nsList[i]] ) current[nsList[ i]] = {}; 
current = current[nsList[i]]; 
} 

var lastLeaf = nsList[nsList.length-1]; 
current[lastLeaf] = merge(current[lastLeaf] || {}, nsObj.getStash()); 
}, 
loadImport: function(nsObj,importName){ 
if( importName ) { 
merge( this.stash, nsObj.getExport(importName) ); 
}else{ 
this._mergeStashWithNS( nsObj ); 
} 
}, 
define: function(callback){ 
var nsDef = this, nsObj = this.namespaceObject; 
this.defineCallback = function($c) { // Assign a value to defineCallback and define the callback function context, two objects, nsDef and nsObj. 
var ns = { 
provide : function(obj){ 
nsObj.merge(obj); 
$c(); 
} 
}; 
merge(ns, nsDef.getStash()); 
merge(ns, nsObj.getStash()); 
callback(ns); 
}; 
} , 
getStash: function(){ 
return this.stash; 
}, 
valueOf: function(){ 
return "#NamespaceDefinition<" this.namespaceObject " > uses :" this.useList.join(','); 
}, 
apply: function(callback){ 
var nsDef = this; 
createProcedure(nsDef. requires) 
.next(nsDef.defineCallback) 
.call(nsDef,function(){ 
callback( nsDef.getStash() ); 
}); 
} 
}); 

var createNamespace = function(fqn){ 
return new NamespaceDefinition( 
NamespaceObjectFactory.create(fqn || 'main') 
); 
}; 
merge(createNamespace, { 
'Object' : NamespaceObjectFactory, 
Definition: NamespaceDefinition, 
Proc : createProcedure 
}); 
return createNamespace; 
})(); 

Additionally define the methods supported by Namespace:
Namespace.use
Namespace.fromInternal
Namespace.GET
Namespace.fromExternal

Copy code The code is as follows:

 
Namespace.use = function(useSyntax){ return Namespace().use(useSyntax); } 
Namespace.fromInternal = Namespace.GET = (function(){ 
var get = (function(){ 
var createRequester = function() { 
var xhr; 
try { xhr = new XMLHttpRequest() } catch(e) { 
try { xhr = new ActiveXObject("Msxml2.XMLHTTP.6.0") } catch(e) { 
try { xhr = new ActiveXObject("Msxml2.XMLHTTP.3.0") } catch(e) { 
try { xhr = new ActiveXObject("Msxml2.XMLHTTP") } catch(e) { 
try { xhr = new ActiveXObject("Microsoft.XMLHTTP") } catch(e) { 
throw new Error( "This browser does not support XMLHttpRequest." ) 
} 
} 
} 
} 
} 
return xhr; 
}; 
var isSuccessStatus = function(status) { 
return (status >= 200 && status < 300) || 
status == 304 || 
status == 1223 || 
(!status && (location.protocol == "file:" || location.protocol == "chrome:") ); 
}; 

return function(url,callback){ 
var xhr = createRequester(); 
xhr.open('GET',url,true); 
xhr.onreadystatechange = function(){ 
if(xhr.readyState === 4){ 
if( isSuccessStatus( xhr.status || 0 )){ 
callback(true,xhr.responseText); 
}else{ 
callback(false); 
} 
} 
}; 
xhr.send('') 
}; 
})(); 

return function(url,isManualProvide){ 
return function(ns){ 
get(url,function(isSuccess,responseText){ 
if( isSuccess ){ 
if( isManualProvide ) 
return eval(responseText); 
else 
return ns.provide( eval( responseText ) ); 
}else{ 
var pub = {}; 
pub[url] = 'loading error'; 
ns.provide(pub); 
} 
}); 
}; 
}; 
})(); 

Namespace.fromExternal = (function(){ 
var callbacks = {}; 
var createScriptElement = function(url,callback){ 
var scriptElement = document.createElement('script'); 

scriptElement.loaded = false; 

scriptElement.onload = function(){ 
this.loaded = true; 
callback(); 
}; 
scriptElement.onreadystatechange = function(){ 
if( !/^(loaded|complete)$/.test( this.readyState )) return; 
if( this.loaded ) return; 
scriptElement.loaded = true; 
callback(); 
}; 
scriptElement.src = url; 
document.body.appendChild( scriptElement ); 
return scriptElement.src; 
}; 
var domSrc = function(url){ 
return function(ns){ 
var src = createScriptElement(url,function(){ 
var name = ns.CURRENT_NAMESPACE; 
var cb = callbacks[name]; 
delete callbacks[name]; 
cb( ns ); 
}); 
} 
}; 
domSrc.registerCallback = function(namespace,callback) { 
callbacks[namespace] = callback; 
}; 
return domSrc; 
})(); 

try{ module.exports = Namespace; }catch(e){} 

具体看一个例子：

复制代码代码如下:

 
Namespace('logtest') 
.define(function (ns) { 
console.log(2); 
ns.provide({ 
log : function () { console.log(3); } 
}); 
}); 

console.log(4); 

Namespace 
.use('logtest') 
.apply( function (ns) { 
console.log(5); 
ns.logtest.log(); 
}); 

1：Namespace('logtest') => new NamespaceDefinition(NamespaceObjectFactory.create('logtest'))
即生成一个NamespaceDefinition对象，该对象是由NamespaceObject对象来初始化的，该对象同时还有三个属性，Object，Definition，Proc。其值依次为 NamespaceObjectFactory，NamespaceDefinition，createProcedure函数对象类。Namespace('logtest') 返回的结果就是生成的NamespaceDefinition对象，然后调用其define方法，初始化defineCallback。此时仅仅是定义，不做具体的动作。

复制代码代码如下:

 
define: function(callback){ 
var nsDef = this, nsObj = this.namespaceObject; 
this.defineCallback = function($c) { // 给defineCallback赋值，同时定义一下该回调函数的上下文，nsDef和nsObj两个对象。 
var ns = { 
provide : function(obj){ 
nsObj.merge(obj); 
$c(); 
} 
}; 
merge(ns, nsDef.getStash()); 
merge(ns, nsObj.getStash()); 
callback(ns); 
}; 
}, 

2: Use the objects in the previously defined namespace, Namespace.use() => Namespace().use() => Namespace('main').use(). Initialize the requirements array when calling use.

Copy code The code is as follows:

 
use: function(syntax){ / / Use namespace 
this.useList.push(syntax); // The namespace string is stored in the array useList 
var splitted = syntax.split(/s /); // Namespace and its objects are used Separate by spaces 
var fqn = splitted[0]; // Get namespace 
var importName = splitted[1]; // Get objects in namespace 
_assertValidFQN(fqn); 
this.requires.push(function($c){ // Put a function into the requires array 
var context = this; 
var require = NamespaceObjectFactory.create(fqn); // Get the specified NamespaceObject Object, previously generated objects can be obtained directly from the cache
require.call(this,function(state){ // Call the call method of the NamespaceObject object
context.loadImport(require,importName); 
$c(); 
}); 
}); 
return this; 
}, 

3: Call main’s apply method. Take a look at the specific apply method

Copy the code The code is as follows:

 
apply: function(callback ){ 
var nsDef = this; 
createProcedure(nsDef.requires) 
.next(nsDef.defineCallback) 
.call(nsDef,function(){ 
callback ( nsDef.getStash() ); 
}); 
} 

Take out the objects in the requires array to generate a Proc object, and put the objects in the requires array into the queue steps , nsDef.defineCallback is also queued (undefined in this example), and the call method of Proc is called. The first parameter is nsDef, and the second parameter is the callback function.
Specific usage:
When defining Namespace, all definitions are placed in define and defined in the form of anonymous functions. function (ns) { // Specific implementation // Define an object that is exposed to the outside world. After using the nsName, the external party can call it through ns.nsName.key() ns.provide({ key : value});}
The advantage of using namespace.js is that all definitions are only executed when needed, that is, the definitions are parsed only when they are actually used.

ps: The specific internal calling relationship is still not clear. I will sort it out when I have time in the future. This article is too messy.