延续上一篇 cordova的原理解释， 参考这里
3. cordova PubSub模式 （channel）
cordova基于观察者模式的，提供了一个自定义的pub-sub模型，基于该模型提供一些事件，用来控制事件什么时候以什么样的顺序被调用，以及事件的调用。
cordova/channel， 的代码结构也是一个很经典的定义结构（构造函数、实例、修改函数原型共享实例方法），它提供事件通道的订阅（subscribe）、撤消订阅（unsubscribe）、调用（fire）等基本方法。最后发布了9个事件。
请看源码 ：
// 定义channel模块
define("cordova/channel", function(require, exports, module) {
var utils = require('cordova/utils'),
nextGuid = 1;
/**
* Channel
* @constructor
* @param type String the channel name
* ①事件通道的构造函数
*/
var Channel = function(type, sticky) {
// 事件通道名称
this.type = type;
// 事件通道上的所有事件处理函数Map（索引为guid）
// Map of guid -> function.
this.handlers = {};
// 事件通道的状态（0：非sticky, 1:sticky但未调用, 2:sticky已调用）
// 0 = Non-sticky, 1 = Sticky non-fired, 2 = Sticky fired.
this.state = sticky ? 1 : 0;
// 传给fire()的参数
// Used in sticky mode to remember args passed to fire().
this.fireArgs = null;
// 当前通道上的事件处理函数的个数
// Used by onHasSubscribersChange to know if there are any listeners.
this.numHandlers = 0;
// 订阅第一个事件或者取消订阅最后一个事件时调用自定义的处理
// Function that is called when the first listener is subscribed, or when
// the last listener is unsubscribed.
this.onHasSubscribersChange = null;
},
// ②事件通道外部接口
channel = {
/**
* Calls the provided function only after all of the channels specified
* have been fired. All channels must be sticky channels.
*/
// 把指定的函数h订阅到c的各个通道上，保证h在每个通道的最后被执行
join: function(h, c) {
var len = c.length,
i = len,
f = function() {
if (!(--i)) h();
};
// 把事件处理函数h订阅到c的各个事件通道上
for (var j=0; j<len; j++) {
// 必须是sticky事件通道
if (c[j].state === 0) {
throw Error('Can only use join with sticky channels.');
}
c[j].subscribe(f);
}
// 执行h
if (!len) h();
},
// 创建事件通道
create: function(type) {
return channel[type] = new Channel(type, false);
},
// 创建sticky事件通道
createSticky: function(type) {
return channel[type] = new Channel(type, true);
},
/**
* cordova Channels that must fire before "deviceready" is fired.
*/
// 调用deviceready事件之前要调用的事件，
deviceReadyChannelsArray: [],
deviceReadyChannelsMap: {},
/**
* Indicate that a feature needs to be initialized before it is ready to be used.
* This holds up Cordova's "deviceready" event until the feature has been initialized
* and Cordova.initComplete(feature) is called.
*
* @param feature {String} The unique feature name
*/
// 设置deviceready事件之前必须要完成的事件
waitForInitialization: function(feature) {
if (feature) {
var c = channel[feature] || this.createSticky(feature);
this.deviceReadyChannelsMap[feature] = c;
this.deviceReadyChannelsArray.push(c);
}
},
/**
* Indicate that initialization code has completed and the feature is ready to be used.
* 表明代码已经初始化，并准备好被使用
* @param feature {String} The unique feature name
*/
initializationComplete: function(feature) {
var c = this.deviceReadyChannelsMap[feature];
if (c) {
c.fire();
}
}
};
// 判断是否函数类型， Js中类型的判断可参考这里
function forceFunction(f) {
if (typeof f != 'function') throw "Function required as first argument!";
}
/**
* Subscribes the given function to the channel. Any time that
* Channel.fire is called so too will the function.
* Optionally specify an execution context for the function
* and a guid that can be used to stop subscribing to the channel.
* Returns the guid.
*/
// ③修改函数原型共享实例方法
// 向事件通道订阅事件处理函数(subscribe部分）
// f:事件处理函数 c:事件的上下文（可省略）
Channel.prototype.subscribe = function(f, c) {
// 判读是否函数
forceFunction(f);
// 如果是被订阅过的sticky事件，就直接调用。
if (this.state == 2) {
f.apply(c || this, this.fireArgs);
return;
}
var func = f,
guid = f.observer_guid;
// 如果事件有上下文，要先把事件函数包装一下带上上下文
if (typeof c == "object") { func = utils.close(c, f); }
// 自增长的ID
if (!guid) {
// first time any channel has seen this subscriber
guid = '' + nextGuid++;
}
// 把自增长的ID反向设置给函数，以后撤消订阅或内部查找用
func.observer_guid = guid;
f.observer_guid = guid;
// 判断该guid索引的事件处理函数是否存在（保证订阅一次）
// Don't add the same handler more than once.
if (!this.handlers[guid]) {
// 订阅到该通道上（索引为guid）
this.handlers[guid] = func;
// 通道上的事件处理函数的个数增加1
this.numHandlers++;
// 如果时间
if (this.numHandlers == 1) {
// 订阅第一个事件时调用自定义的处理（比如：第一次按下返回按钮提示“再按一次...”）
this.onHasSubscribersChange && this.onHasSubscribersChange();
}
}
};
/**
* Unsubscribes the function with the given guid from the channel.
*/
// 撤消订阅通道上的某个函数（guid）
Channel.prototype.unsubscribe = function(f) {
// need a function to unsubscribe
// 事件处理函数校验
forceFunction(f);
// 事件处理函数的guid索引
var guid = f.observer_guid,
// 事件处理函数
handler = this.handlers[guid];
if (handler) {
// 从该通道上撤消订阅（索引为guid）
delete this.handlers[guid];
// 通道上的事件处理函数的个数减1
this.numHandlers--;
if (this.numHandlers === 0) {
// 撤消订阅最后一个事件时调用自定义的处理
this.onHasSubscribersChange && this.onHasSubscribersChange();
}
}
};
/**
* Calls all functions subscribed to this channel.
*/
// 调用所有被发布到该通道上的函数
Channel.prototype.fire = function(e) {
var fail = false,
fireArgs = Array.prototype.slice.call(arguments);
// Apply stickiness.
// sticky事件被调用时，标示为已经调用过。
if (this.state == 1) {
this.state = 2;
this.fireArgs = fireArgs;
}
if (this.numHandlers) {
// 把该通道上的所有事件处理函数拿出来放到一个数组中。
var toCall = [];
for (var item in this.handlers) {
toCall.push(this.handlers[item]);
}
// 依次调用通道上的所有事件处理函数
for (var i = 0; i < toCall.length; ++i) {
toCall[i].apply(this, fireArgs);
}
// sticky事件是一次性全部被调用的，调用完成后就清空。
if (this.state == 2 && this.numHandlers) {
this.numHandlers = 0;
this.handlers = {};
this.onHasSubscribersChange && this.onHasSubscribersChange();
}
}
};
// ④创建事件通道（publish部分）-----------------------
// （内部事件通道）页面加载后DOM解析完成
channel.createSticky('onDOMContentLoaded');
// （内部事件通道）Cordova的native准备完成
channel.createSticky('onNativeReady');
// （内部事件通道）所有Cordova的JavaScript对象被创建完成可以开始加载插件
channel.createSticky('onCordovaReady');
// （内部事件通道）所有自动load的插件js已经被加载完成
channel.createSticky('onPluginsReady');
// Cordova全部准备完成
channel.createSticky('onDeviceReady');
// 应用重新返回前台
channel.create('onResume');
// 应用暂停退到后台
channel.create('onPause');
// （内部事件通道）应用被关闭（window.onunload）
channel.createSticky('onDestroy');
// ⑤设置deviceready事件之前必须要完成的事件
// ***onNativeReady和onPluginsReady是平台初期化之前要完成的。
channel.waitForInitialization('onCordovaReady');
channel.waitForInitialization('onDOMContentLoaded');
module.exports = channel;
});
以上是源码，下面说说理解
---1####
，首先定义几个变量，utils， nextGuid, Channel, channel , utils就是前面两篇文章分析的工具模块；nextGuid 就是一个Guid; Channel是一个普通的构造器方法；channel则是最终返回的结果。
注意到下面这一段代码（将所有具体逻辑省略） , 将Channel的定义及其原型的修改放在一起，我们可以看到一个典型的创建对象的方法：通过构造器初始化内部变量，从而让各个实例互相独立，通过修改函数原型共享实例方法。
var Channel = function(type, sticky) {
// 通过构造器初始化内部变量
},
channel = {
// 创建对象函数
Channel.prototype.subscribe = function(f, c) {
// subscribe（向事件通道注入事件处理函数）
}；
Channel.prototype.unsubscribe = function(f) {
// 解除事件处理函数，反注入
}；
Channel.prototype.fire = function(e) {
// fire（触发所有注入的函数）
}；
---2####
subscribe是向通道注入事件处理函数的函数，这个函数，是负责将函数注入事件通道的、通过一个自增长GUID为注入函数的索引。
unsubscribe 是反注入，就是将通过subscribe注入到通道的函数删除，通过guid，找到this. handler中保存的响应函数，并且删除。
fire 调用、触发注入函数， 主要是修改 sticky事件状态，构造调用函数的数组, 并且一次调用所有事件处理函数（利用了apply()函数实例方法调用 ）
4. cordova 工具类 （utils）
// file: src/common/utils.js
define("cordova/utils", function(require, exports, module) {
//exports是一个{ }空对象, 赋值给utils
var utils = exports;
/**
* Defines a property getter / setter for obj[key].
*/
utils.defineGetterSetter = function(obj, key, getFunc, opt_setFunc) {
if (Object.defineProperty) {
var desc = {
get: getFunc,
configurable: true
};
if (opt_setFunc) {
desc.set = opt_setFunc;
}
Object.defineProperty(obj, key, desc);
} else {
obj.__defineGetter__(key, getFunc);
if (opt_setFunc) {
obj.__defineSetter__(key, opt_setFunc);
}
}
};
/**
* 通过 obj[key]. 定义一个Getter方法（内部调用utils.defineGetterSetter）
*/
utils.defineGetter = utils.defineGetterSetter;
utils.arrayIndexOf = function(a, item) {
if (a.indexOf) {
return a.indexOf(item);
}
var len = a.length;
for (var i = 0; i < len; ++i) {
if (a[i] == item) {
return i;
}
}
return -1;
};
/**
* 返回该项目是否在数组中。
*/
utils.arrayRemove = function(a, item) {
var index = utils.arrayIndexOf(a, item);
if (index != -1) {
a.splice(index, 1);
}
return index != -1;
};
utils.typeName = function(val) {
return Object.prototype.toString.call(val).slice(8, -1);
};
/**
* 判断一个对象是否为Array类型
*/
utils.isArray = Array.isArray ||
function(a) {return utils.typeName(a) == 'Array';};
/**
* 判断一个对象是否为Date类型
*/
utils.isDate = function(d) {
return (d instanceof Date);
};
/**
* 深度copy一个对象，包括这个对象的事件等
*/
utils.clone = function(obj) {
if(!obj || typeof obj == 'function' || utils.isDate(obj) || typeof obj != 'object') {
return obj;
}
var retVal, i;
if(utils.isArray(obj)){
retVal = [];
for(i = 0; i < obj.length; ++i){
retVal.push(utils.clone(obj[i]));
}
return retVal;
}
retVal = {};
for(i in obj){
if(!(i in retVal) || retVal[i] != obj[i]) {
retVal[i] = utils.clone(obj[i]);
}
}
return retVal;
};
/**
* 对一个函数的包装调用
*/
utils.close = function(context, func, params) {
return function() {
var args = params || arguments;
return func.apply(context, args);
};
};
//------------------------------------------------------------------------------
// 内部私有函数 ， UUIDcreatePart函数用来随机产生一个16进制的号码，接受一个表示号码长度的参数（实际上是最终号码长度的一半），一般用途是做为元素的唯一ID；
function UUIDcreatePart(length) {
var uuidpart = "";
for (var i=0; i<length; i++) {
var uuidchar = parseInt((Math.random() * 256), 10).toString(16);
if (uuidchar.length == 1) {
uuidchar = "0" + uuidchar;
}
uuidpart += uuidchar;
}
return uuidpart;
}
/**
* 产生随机字符串 （UUID）
*/
utils.createUUID = function() {
return UUIDcreatePart(4) + '-' +
UUIDcreatePart(2) + '-' +
UUIDcreatePart(2) + '-' +
UUIDcreatePart(2) + '-' +
UUIDcreatePart(6);
};
/**
* 继承子对象
*/
utils.extend = (function() {
// proxy used to establish prototype chain
var F = function() {};
// extend Child from Parent
return function(Child, Parent) {
F.prototype = Parent.prototype;
Child.prototype = new F();
Child.__super__ = Parent.prototype;
Child.prototype.constructor = Child;
};
}());
/**
* 弹出消息，不支持弹出消息时，写日志到控制台
*/
utils.alert = function(msg) {
if (window.alert) {
window.alert(msg);
} else if (console && console.log) {
console.log(msg);
}
};
});
附上JS一些函数的解析
（1）push():接受任意数量的参数，逐个添加到数组末尾，并返回修改后数组长度
（2）pop():移除最后一项，修改数组长度，返回被移除的项
（3）shift():移除数组第一项，修改数组长度，返回被移除的项
（4）unshift():在数组前端添加任意个项，并返回数组长度
（5）slice()：基于当前数组的一个或多个项创建一个新数组，可以接受1或2个参数，即要返回项的起始和结束位置，只有一个参数时，返回从该参数指定位置开始到末尾，有两个参数，返回这两个参数之间项（前闭后开区间），slice不会影响原数组。若参数为负数，则用数组长度加上参数直至为正数，若结束位置小于起始位置，返回空数组。
（6）splice()：返回从原数组中删除的项构成的数组，若没有删除，返回空数组
删除：可以删除任意数量的项，只需指定2个参数，要删除的第一项的位置和要删除的项数，如splice(0,2)会删除前面两项
插入：可以向指定位置插入任意数量的项，只需提供3个参数，起始位置，0（要删除的数），要插入的项，如果要插入多个项，可以传入第四、第五以至任意多个项
替换：可以向指定位置插入任意数量的项，且同时删除任意数量的项
