[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8},"actionData","errors","root",{"_11":-5},"routes/user.$name.replies",{"_9":10,"_11":12,"_13":14,"_15":16,"_17":18,"_19":16},"replies",[35],"user",{"_20":21,"_13":14,"_22":23,"_24":14,"_25":26,"_27":28,"_29":30,"_31":32,"_33":34},"loginname","gmailzj","page",1,"limit",50,"total","id","20374","avatar_url","https://avatars0.githubusercontent.com/u/2996820?v=4","githubUsername","create_at","2016-01-04 17:15:05.261","score",25,"topic_count",2,"reply_count",3,"is_star",false,{"_20":36,"_37":21,"_38":39,"_40":41,"_42":43,"_44":45,"_46":34,"_47":34,"_31":48,"_49":50,"_25":51,"_52":53},"25155","author_id","tab","share","content","最近用到 [eventproxy](https://github.com/JacksonTian/eventproxy), 本着知其然的态度，分析了下其源码，有兴趣的可以看看。 [eventproxy源码分析](https://github.com/gmailzj/eventproxy)\r\n```js\r\n/*global define*/ !(function(name, definition) {\r\n // Check define\r\n var hasDefine = typeof define === 'function',\r\n // Check exports\r\n hasExports = typeof module !== 'undefined' && module.exports;\r\n\r\n if (hasDefine) {\r\n // AMD Module or CMD Module\r\n define('eventproxy_debug', function() { return function() {}; });\r\n define(['eventproxy_debug'], definition);\r\n } else if (hasExports) {\r\n // Node.js Module\r\n module.exports = definition(require('debug')('eventproxy'));\r\n } else {\r\n // Assign to common namespaces or simply the global object (window)\r\n this[name] = definition();\r\n }\r\n})('EventProxy', function(debug) {\r\n debug = debug || function() {};\r\n\r\n /*!\r\n * refs\r\n */\r\n var SLICE = Array.prototype.slice;\r\n var CONCAT = Array.prototype.concat;\r\n var ALL_EVENT = '__all__';\r\n\r\n /**\r\n * EventProxy. An implementation of task/event based asynchronous pattern.\r\n * A module that can be mixed in to *any object* in order to provide it with custom events.\r\n * You may `bind` or `unbind` a callback function to an event;\r\n * `trigger`-ing an event fires all callbacks in succession.\r\n * Examples:\r\n * ```js\r\n * var render = function (template, resources) {};\r\n * var proxy = new EventProxy();\r\n * proxy.assign(\"template\", \"l10n\", render);\r\n * proxy.trigger(\"template\", template);\r\n * proxy.trigger(\"l10n\", resources);\r\n * ```\r\n */\r\n var EventProxy = function() {\r\n // 防止直接调用构造函数\r\n if (!(this instanceof EventProxy)) {\r\n return new EventProxy();\r\n }\r\n this._callbacks = {};\r\n this._fired = {};\r\n };\r\n\r\n /**\r\n * Bind an event, specified by a string name, `ev`, to a `callback` function.\r\n * Passing __ALL_EVENT__ will bind the callback to all events fired.\r\n * Examples:\r\n * ```js\r\n * var proxy = new EventProxy();\r\n * proxy.addListener(\"template\", function (event) {\r\n * // TODO\r\n * });\r\n * ```\r\n * @param {String} eventname Event name.\r\n * @param {Function} callback Callback.\r\n */\r\n EventProxy.prototype.addListener = function(ev, callback) {\r\n // 其实只是把事件处理回调加入到回调队列，在trigger的时候用到\r\n // 程序中也可以单独对某件事件添加处理函数\r\n debug('Add listener for %s', ev);\r\n // 常用手法添加一项并且作为数组使用并且初始化，这样运行的时候不会出错\r\n this._callbacks[ev] = this._callbacks[ev] || [];\r\n // 加入到回调队列中\r\n this._callbacks[ev].push(callback);\r\n return this;\r\n };\r\n /**\r\n * `addListener` alias, `bind` ，`on`，`subscribe` 等价\r\n */\r\n EventProxy.prototype.bind = EventProxy.prototype.addListener;\r\n /**\r\n * `addListener` alias, `on`\r\n */\r\n EventProxy.prototype.on = EventProxy.prototype.addListener;\r\n /**\r\n * `addListener` alias, `subscribe`\r\n */\r\n EventProxy.prototype.subscribe = EventProxy.prototype.addListener;\r\n\r\n /**\r\n * Bind an event, but put the callback into head of all callbacks.\r\n * @param {String} eventname Event name.\r\n * @param {Function} callback Callback.\r\n */\r\n EventProxy.prototype.headbind = function(ev, callback) {\r\n // 添加到事件处理队列的最前面\r\n debug('Add listener for %s', ev);\r\n this._callbacks[ev] = this._callbacks[ev] || [];\r\n this._callbacks[ev].unshift(callback);\r\n return this;\r\n };\r\n\r\n /**\r\n * Remove one or many callbacks. 取消事件处理回调\r\n *\r\n * - If `callback` is null, removes all callbacks for the event.\r\n * - If `eventname` is null, removes all bound callbacks for all events.\r\n * @param {String} eventname Event name.\r\n * @param {Function} callback Callback.\r\n */\r\n EventProxy.prototype.removeListener = function(eventname, callback) {\r\n var calls = this._callbacks;\r\n if (!eventname) { // 如果不加事件名，清除所有的回调\r\n debug('Remove all listeners');\r\n this._callbacks = {};\r\n } else {\r\n if (!callback) { // 没有提供参数回调，清除eventname事件的所有回调\r\n debug('Remove all listeners of %s', eventname);\r\n calls[eventname] = [];\r\n } else { // 得到事件名和回调\r\n var list = calls[eventname];\r\n if (list) {\r\n var l = list.length;\r\n for (var i = 0; i < l; i++) {\r\n if (callback === list[i]) { // 如果找到了回调删除回调\r\n debug('Remove a listener of %s', eventname);\r\n list[i] = null;\r\n }\r\n }\r\n }\r\n }\r\n }\r\n return this;\r\n };\r\n /**\r\n * `removeListener` alias, unbind 等价\r\n */\r\n EventProxy.prototype.unbind = EventProxy.prototype.removeListener;\r\n\r\n /**\r\n * Remove all listeners. It equals unbind()\r\n * Just add this API for as same as Event.Emitter.\r\n * @param {String} event Event name.\r\n */\r\n EventProxy.prototype.removeAllListeners = function(event) {\r\n return this.unbind(event);\r\n };\r\n\r\n /**\r\n * Bind the ALL_EVENT event 注册任务完成的事件处理函数\r\n */\r\n EventProxy.prototype.bindForAll = function(callback) {\r\n //console.log(ALL_EVENT)\r\n this.bind(ALL_EVENT, callback);\r\n };\r\n\r\n /**\r\n * Unbind the ALL_EVENT event 取消监听任务完成\r\n */\r\n EventProxy.prototype.unbindForAll = function(callback) {\r\n this.unbind(ALL_EVENT, callback);\r\n };\r\n\r\n /**\r\n * Trigger an event, firing all bound callbacks. Callbacks are passed the\r\n * same arguments as `trigger` is, apart from the event name.\r\n * Listening for `\"all\"` passes the true event name as the first argument.\r\n * @param {String} eventname Event name\r\n * @param {Mix} data Pass in data\r\n */\r\n EventProxy.prototype.trigger = function(eventname, data) {\r\n debug(\"trigger:\", eventname)\r\n var list, ev, callback, i, l;\r\n var both = 2;\r\n var calls = this._callbacks;\r\n // console.log(calls);\r\n debug('Emit event %s with data %j', eventname, data);\r\n while (both--) {\r\n // 注意第一次运行到这里 both已经等于1了，如果是等于0，说明是用来最后处理ALL_EVENT(全部完成的事件bindForAll)\r\n // 也就是说每一次trigger单个事件的时候，其实也会触发ALL_EVENT事件，\r\n // 但是ALL_EVENT事件是否完成，最终的判断是在_assign函数的_all函数中\r\n\r\n // 事件名\r\n ev = both ? eventname : ALL_EVENT;\r\n list = calls[ev]; // 得到回调列表\r\n if (list) {\r\n // 遍历所有的回调, 一个事件可能有多个绑定回调，比如用户自定义bind\r\n for (i = 0, l = list.length; i < l; i++) {\r\n // 注意上一轮(both=1)的回调\r\n\r\n // 有两种可能：\r\n // 1 用户自定回调为false，\r\n // 2 单个事件回调已经执行了, 会在removeListener中执行 unbind，\r\n if (!(callback = list[i])) {\r\n debug(callback, 'alert')\r\n // 删掉该list中的item\r\n list.splice(i, 1);\r\n\r\n // 下面两行相当于重来一次循环判断\r\n i--;\r\n l--;\r\n } else { // callback 为真\r\n // console.log(callback)\r\n var args = [];\r\n // 如果是单个事件过滤掉第一个参数事件名，只要data\r\n // ALL_EVENT的话，需要包括事件名, after方法中有用到事件名和data\r\n var start = both ? 1 : 0;\r\n for (var j = start; j < arguments.length; j++) {\r\n args.push(arguments[j]);\r\n }\r\n // console.log(args);\r\n // callback 必须是函数，用户自定义bind的时候，没有强制规定\r\n callback.apply(this, args);\r\n }\r\n }\r\n }\r\n }\r\n return this;\r\n };\r\n\r\n /**\r\n * `trigger` alias emit、trigger、fire 等价都是触发事件的意思\r\n */\r\n EventProxy.prototype.emit = EventProxy.prototype.trigger;\r\n /**\r\n * `trigger` alias\r\n */\r\n EventProxy.prototype.fire = EventProxy.prototype.trigger;\r\n\r\n /**\r\n * Bind an event like the bind method, but will remove the listener after it was fired.\r\n * @param {String} ev Event name\r\n * @param {Function} callback Callback\r\n */\r\n EventProxy.prototype.once = function(ev, callback) {\r\n // 和bind的区别就是\r\n var self = this;\r\n // 里面包装一个unbind, 当第一次执行以后，unbind，就相当于只能once\r\n var wrapper = function() {\r\n //console.log(arguments)\r\n // 这里arguments是指真正 wrapper 执行的时候的参数\r\n callback.apply(self, arguments);\r\n self.unbind(ev, wrapper);\r\n };\r\n\r\n // 真正绑定\r\n this.bind(ev, wrapper);\r\n return this;\r\n };\r\n\r\n // later等于下面的三个选择之一。优先级：setImmediate > process.nextTick > setTimeout(fn, 0);\r\n var later = (typeof setImmediate !== 'undefined' && setImmediate) ||\r\n (typeof process !== 'undefined' && process.nextTick) || function(fn) {\r\n setTimeout(fn, 0);\r\n };\r\n\r\n /**\r\n * emitLater\r\n * make emit async 异步事件触发\r\n */\r\n EventProxy.prototype.emitLater = function() {\r\n var self = this;\r\n var args = arguments;\r\n later(function() { // 通过上面的later方案\r\n self.trigger.apply(self, args);\r\n });\r\n };\r\n\r\n /**\r\n * Bind an event, and trigger it immediately. 绑定并立即执行，传递事件名、事件发生以后的回调、触发时传递的数据\r\n * @param {String} ev Event name.\r\n * @param {Function} callback Callback.\r\n * @param {Mix} data The data that will be passed to calback as arguments.\r\n */\r\n EventProxy.prototype.immediate = function(ev, callback, data) {\r\n this.bind(ev, callback);\r\n this.trigger(ev, data);\r\n return this;\r\n };\r\n /**\r\n * `immediate` alias 和 immediate 别名等价\r\n */\r\n EventProxy.prototype.asap = EventProxy.prototype.immediate;\r\n\r\n // 设置最终回调和事件列表\r\n var _assign = function(eventname1, eventname2, cb, once) {\r\n // 引用this\r\n var proxy = this;\r\n var argsLength = arguments.length;\r\n var times = 0;\r\n var flag = {};\r\n\r\n // Check the arguments length. 最起码有3个参数：一个事件名和一个回调和一个标记once(内部赋值，::all方法里面)\r\n if (argsLength < 3) {\r\n return this;\r\n }\r\n\r\n // 所有的事件参数\r\n var events = SLICE.call(arguments, 0, -2);\r\n\r\n // 最终回调cb\r\n var callback = arguments[argsLength - 2];\r\n\r\n // true 表示isOnce为真，all的时候赋值为 true\r\n var isOnce = arguments[argsLength - 1];\r\n\r\n // Check the callback type.\r\n if (typeof callback !== \"function\") {\r\n return this;\r\n }\r\n debug('Assign listener for events %j, once is %s', events, !!isOnce);\r\n\r\n // key 表示的是事件名\r\n var bind = function(key) {\r\n // 根据isOnce判断method为once或者bind\r\n var method = isOnce ? \"once\" : \"bind\";\r\n\r\n // 在这里绑定每个事件handler proxy[method] 对应 this.once、this.bind方法\r\n // 在应用中的区别就是\r\n // ep.tail的时候会使用bind，这样只要事件成功触发过，然后重复提交任意其中1个事件(tail绑定) 都会触发ALL_EVENT\r\n proxy[method](key, function(data) {\r\n // 这里才是真正的单个事件处理 handler\r\n\r\n // this._fired[key] 初始化\r\n proxy._fired[key] = proxy._fired[key] || {};\r\n\r\n // 存储已经触发的事件的数据, ALL_EVENT回调用到\r\n proxy._fired[key].data = data;\r\n // flag[key]列表中标记key 不存在的时候表示第一次触发事件才是是真正合法的\r\n if (!flag[key]) {\r\n flag[key] = true;\r\n times++;\r\n }\r\n });\r\n };\r\n\r\n // 绑定多个自定义事件\r\n var length = events.length;\r\n for (var index = 0; index < length; index++) {\r\n bind(events[index]); // 参数为事件名key\r\n }\r\n // ALL_EVENT 回调, 但是不代表真正完成ALL_EVENT，单个事件触发的时候也会这些这里，然后在里面判断是否完成\r\n // 第一个参数\r\n var _all = function(event) {\r\n console.log('开始ALL_EVENT 是否完成判断：', times, length, flag[event], event);\r\n\r\n // '开始ALL_EVENT 是否完成判断：'\r\n if (times < length) { // 如果事件触发的次数小于总的事件数量\r\n return;\r\n }\r\n if (!flag[event]) {\r\n return;\r\n }\r\n var data = [];\r\n // 这里就是获取ALL_EVENT回调的参数\r\n for (var index = 0; index < length; index++) {\r\n data.push(proxy._fired[events[index]].data);\r\n }\r\n if (isOnce) { // 如果是一次性事件，注册ubindForAll事件处理\r\n proxy.unbindForAll(_all);\r\n }\r\n debug('Events %j all emited with data %j', events, data);\r\n // 真正传递数据并执行回调\r\n callback.apply(null, data);\r\n };\r\n proxy.bindForAll(_all);\r\n };\r\n\r\n /**\r\n * Assign some events, after all events were fired, the callback will be executed once.\r\n *\r\n * Examples:\r\n * ```js\r\n * proxy.all(ev1, ev2, callback);\r\n * proxy.all([ev1, ev2], callback);\r\n * proxy.all(ev1, [ev2, ev3], callback);\r\n * ```\r\n * @param {String} eventname1 First event name.\r\n * @param {String} eventname2 Second event name.\r\n * @param {Function} callback Callback, that will be called after predefined events were fired.\r\n */\r\n EventProxy.prototype.all = function(eventname1, eventname2, callback) {\r\n // 主要是为了合并事件参数\r\n var args = CONCAT.apply([], arguments);\r\n args.push(true);\r\n // console.log(args)\r\n _assign.apply(this, args);\r\n return this;\r\n };\r\n /**\r\n * `all` alias\r\n */\r\n EventProxy.prototype.assign = EventProxy.prototype.all;\r\n\r\n /**\r\n * Assign the only one 'error' event handler.\r\n * @param {Function(err)} callback\r\n */\r\n EventProxy.prototype.fail = function(callback) {\r\n var that = this;\r\n\r\n that.once('error', function() {\r\n that.unbind();\r\n // put all arguments to the error handler\r\n // fail(function(err, args1, args2, ...){})\r\n callback.apply(null, arguments);\r\n });\r\n return this;\r\n };\r\n\r\n /**\r\n * A shortcut of ep#emit('error', err)\r\n */\r\n EventProxy.prototype.throw = function() {\r\n var that = this;\r\n that.emit.apply(that, ['error'].concat(SLICE.call(arguments)));\r\n };\r\n\r\n /**\r\n * Assign some events, after all events were fired, the callback will be executed first time.\r\n * Then any event that predefined be fired again, the callback will executed with the newest data.\r\n * Examples:\r\n * ```js\r\n * proxy.tail(ev1, ev2, callback);\r\n * proxy.tail([ev1, ev2], callback);\r\n * proxy.tail(ev1, [ev2, ev3], callback);\r\n * ```\r\n * @param {String} eventname1 First event name.\r\n * @param {String} eventname2 Second event name.\r\n * @param {Function} callback Callback, that will be called after predefined events were fired.\r\n */\r\n EventProxy.prototype.tail = function() {\r\n var args = CONCAT.apply([], arguments);\r\n args.push(false); // 和EventProxy.prototype.all的唯一区别 true=>false，从而来控制bind 和once\r\n _assign.apply(this, args);\r\n return this;\r\n };\r\n /**\r\n * `tail` alias, assignAll\r\n */\r\n EventProxy.prototype.assignAll = EventProxy.prototype.tail;\r\n /**\r\n * `tail` alias, assignAlways\r\n */\r\n EventProxy.prototype.assignAlways = EventProxy.prototype.tail;\r\n\r\n /**\r\n * The callback will be executed after the event be fired N times.\r\n * @param {String} eventname Event name.\r\n * @param {Number} times N times.\r\n * @param {Function} callback Callback, that will be called after event was fired N times.\r\n */\r\n EventProxy.prototype.after = function(eventname, times, callback) {\r\n // 重复异步协作\r\n // 如果参数times为0，直接执行回调, 参数为数组[]\r\n if (times === 0) {\r\n callback.call(null, []);\r\n return this;\r\n }\r\n var proxy = this,\r\n firedData = [];\r\n // _after 初始化\r\n this._after = this._after || {};\r\n // 根据事件名设置分组名\r\n var group = eventname + '_group';\r\n // 存储分组事件的数据\r\n this._after[group] = {\r\n index: 0,\r\n results: []\r\n };\r\n debug('After emit %s times, event %s\\'s listenner will execute', times, eventname);\r\n\r\n // 设置所有事件完成以后的回调\r\n var all = function(name, data) {\r\n if (name === eventname) { // 到处都是闭包事件名\r\n times--;\r\n // 将数据添加到list列表\r\n firedData.push(data);\r\n if (times < 1) { // 说明已经完成了\r\n debug('Event2 %s was emit %s, and execute the listenner', eventname, times);\r\n // 解绑事件监听\r\n proxy.unbindForAll(all);\r\n // 事件完成调用回调\r\n callback.apply(null, [firedData]);\r\n }\r\n }\r\n if (name === group) { // 到处都是闭包事件组名 ep.group('got_file') ,实际是ep.emit的groupname\r\n times--;\r\n // 换一种group方式将数据添加到list列表\r\n proxy._after[group].results[data.index] = data.result;\r\n if (times < 1) { // 说明已经完成了\r\n debug('Event %s was emit %s, and execute the listenner', eventname, times);\r\n // 解绑事件监听\r\n proxy.unbindForAll(all);\r\n // 事件完成调用回调\r\n callback.call(null, proxy._after[group].results);\r\n }\r\n }\r\n };\r\n proxy.bindForAll(all);\r\n return this;\r\n };\r\n\r\n /**\r\n * The `after` method's helper. Use it will return ordered results.\r\n * If you need manipulate result, you need callback\r\n * Examples:\r\n * ```js\r\n * var ep = new EventProxy();\r\n * ep.after('file', files.length, function (list) {\r\n * // Ordered results\r\n * });\r\n * for (var i = 0; i < files.length; i++) {\r\n * fs.readFile(files[i], 'utf-8', ep.group('file'));\r\n * }\r\n * ```\r\n * @param {String} eventname Event name, shoule keep consistent with `after`.\r\n * @param {Function} callback Callback function, should return the final result.\r\n */\r\n EventProxy.prototype.group = function(eventname, callback) {\r\n var that = this;\r\n var group = eventname + '_group'; // 分组名称\r\n var index = that._after[group].index;\r\n that._after[group].index++;\r\n return function(err, data) {\r\n if (err) { // 错误处理\r\n // put all arguments to the error handler 提交错误\r\n return that.emit.apply(that, ['error'].concat(SLICE.call(arguments)));\r\n }\r\n that.emit(group, { // 提交事件组\r\n index: index,\r\n // callback(err, args1, args2, ...) 如果ep.group()的时候提供了callback参数，就是增加中间层加工data\r\n result: callback ? callback.apply(null, SLICE.call(arguments, 1)) : data\r\n });\r\n };\r\n };\r\n\r\n /**\r\n * The callback will be executed after any registered event was fired. It only executed once.\r\n * 回调将在任意一个注册了的事件触发以后执行，而且只执行一次\r\n * @param {String} eventname1 Event name.\r\n * @param {String} eventname2 Event name.\r\n * @param {Function} callback The callback will get a map that has data and eventname attributes.\r\n */\r\n EventProxy.prototype.any = function() {\r\n var proxy = this,\r\n callback = arguments[arguments.length - 1], // 最后一个参数为callback\r\n events = SLICE.call(arguments, 0, -1), // 事件名数组\r\n _eventname = events.join(\"_\"); // eg: event1_event2_event3\r\n\r\n debug('Add listenner for Any of events %j emit', events);\r\n proxy.once(_eventname, callback); // 只执行一次\r\n\r\n var _bind = function(key) {\r\n proxy.bind(key, function(data) { // 对每一个事件绑定\r\n debug('One of events %j emited, execute the listenner');\r\n proxy.trigger(_eventname, { \"data\": data, eventName: key }); // 触发`event1_event2_event3`事件\r\n });\r\n };\r\n\r\n for (var index = 0; index < events.length; index++) {\r\n _bind(events[index]);\r\n }\r\n };\r\n\r\n /**\r\n * The callback will be executed when the event name not equals with assigned event.\r\n * @param {String} eventname Event name.\r\n * @param {Function} callback Callback.\r\n */\r\n EventProxy.prototype.not = function(eventname, callback) {\r\n var proxy = this;\r\n debug('Add listenner for not event %s', eventname);\r\n\r\n // 这里绑定 ALL_EVENT ，在trigger单个事件的时候，在trigger方法里面会有ALL_EVENT的判断\r\n proxy.bindForAll(function(name, data) {\r\n if (name !== eventname) {\r\n debug('listenner execute of event %s emit, but not event %s.', name, eventname);\r\n callback(data); // 传递数据并执行回调\r\n }\r\n });\r\n };\r\n\r\n /**\r\n * Success callback wrapper, will handler err for you.\r\n *\r\n * ```js\r\n * fs.readFile('foo.txt', ep.done('content'));\r\n *\r\n * // equal to =>\r\n *\r\n * fs.readFile('foo.txt', function (err, content) {\r\n * if (err) {\r\n * return ep.emit('error', err);\r\n * }\r\n * ep.emit('content', content);\r\n * });\r\n * ```\r\n *\r\n * ```js\r\n * fs.readFile('foo.txt', ep.done('content', function (content) {\r\n * return content.trim();\r\n * }));\r\n *\r\n * // equal to =>\r\n *\r\n * fs.readFile('foo.txt', function (err, content) {\r\n * if (err) {\r\n * return ep.emit('error', err);\r\n * }\r\n * ep.emit('content', content.trim());\r\n * });\r\n * ```\r\n * @param {Function|String} handler, success callback or event name will be emit after callback.\r\n * @return {Function}\r\n */\r\n EventProxy.prototype.done = function(handler, callback) {\r\n var that = this;\r\n return function(err, data) {\r\n\r\n if (err) {\r\n // put all arguments to the error handler\r\n // 如果出错了，提交error\r\n return that.emit.apply(that, ['error'].concat(SLICE.call(arguments)));\r\n }\r\n\r\n // callback(err, args1, args2, ...)\r\n // 得到数据\r\n var args = SLICE.call(arguments, 1);\r\n\r\n if (typeof handler === 'string') { // 如果第一个参数是字符串\r\n // getAsync(query, ep.done('query'));\r\n // or\r\n // getAsync(query, ep.done('query', function (data) {\r\n // return data.trim();\r\n // }));\r\n if (callback) { // 如果有回调，其实就是数据加工函数\r\n // only replace the args when it really return a result\r\n return that.emit(handler, callback.apply(null, args));\r\n } else {\r\n // put all arguments to the done handler\r\n //ep.done('some');\r\n //ep.on('some', function(args1, args2, ...){}); 触发事件，并传递数据\r\n return that.emit.apply(that, [handler].concat(args));\r\n }\r\n }\r\n\r\n // speed improve for mostly case: `callback(err, data)`\r\n if (arguments.length <= 2) { // 第一个参数是函数需要手动emit\r\n // console.log(\"<=2\")\r\n return handler(data);\r\n }\r\n\r\n // callback(err, args1, args2, ...)\r\n handler.apply(null, args);\r\n // console.log(\"last\")\r\n };\r\n };\r\n\r\n /**\r\n * make done async\r\n * @return {Function} delay done\r\n */\r\n EventProxy.prototype.doneLater = function(handler, callback) {\r\n var _doneHandler = this.done(handler, callback);\r\n return function(err, data) {\r\n var args = arguments;\r\n later(function() {\r\n _doneHandler.apply(null, args);\r\n });\r\n };\r\n };\r\n\r\n /**\r\n * Create a new EventProxy\r\n * Examples:\r\n * ```js\r\n * var ep = EventProxy.create();\r\n * ep.assign('user', 'articles', function(user, articles) {\r\n * // do something...\r\n * });\r\n * // or one line ways: Create EventProxy and Assign\r\n * var ep = EventProxy.create('user', 'articles', function(user, articles) {\r\n * // do something...\r\n * });\r\n * ```\r\n * @return {EventProxy} EventProxy instance\r\n */\r\n EventProxy.create = function() {\r\n var ep = new EventProxy();\r\n var args = CONCAT.apply([], arguments);\r\n if (args.length) {\r\n // 假设最后1个是errorHandler, 倒数第2个是回调\r\n var errorHandler = args[args.length - 1];\r\n var callback = args[args.length - 2];\r\n if (typeof errorHandler === 'function' && typeof callback === 'function') {\r\n\r\n // 处理好errorHandler,\r\n args.pop();\r\n ep.fail(errorHandler);\r\n }\r\n // 开始真正的assign\r\n ep.assign.apply(ep, args);\r\n }\r\n return ep;\r\n };\r\n\r\n // Backwards compatibility\r\n EventProxy.EventProxy = EventProxy;\r\n\r\n return EventProxy;\r\n});\r\n```","title","eventproxy 原理分析","last_reply_at","2017-08-17 11:31:12.001","good","top",6,"visit_count",5823,"2017-05-25 10:25:21.892","author",{"_13":14,"_22":23}]