读jQuery之十三 添加事件和删除事件的核心方法

jQuery的事件模块严重依赖于其数据储存(jQuery.data)，你会发现我的代码中的dataManager对象对应它。
这里只提供bind和unbind方法。暂不包含
1， 事件命名空间(event namespace)
2， 事件代理(event delegation)
3， 特殊事件如dom ready
接口如下：

1. E.bind(el, 'click', fn);
   
2. E.bind(el, 'click', fn, data);
   
3. E.unbind(el, 'click', fn);
   
4. E.unbind(el, 'click');
   
5. E.unbind(el);

复制代码

1. /**
   
2. * Event from jQuery
   
3. * 2011-06-20 snandy
   
4. *
   
5. * A number of helper functions used for managing events.
   
6. * Many of the ideas behind this code originated from jQuery library (1.6.2).
   
7. *
   
8. * example
   
9. *
   
10. * E.bind(el, 'click', fn);
    
11. *
    
12. * E.bind(el, 'click', fn, data);
    
13. *
    
14. * E.unbind(el, 'click', fn);
    
15. *
    
16. * E.unbind(el, 'click');
    
17. *
    
18. * E.unbind(el);
    
19. *
    
20. */
    
21. E = function( window ) {
    
22. var uuid = 0,
    
23. globalCache = {},
    
24. doc = window.document,
    
25. w3c = !!doc.addEventListener,
    
26. expando = 'snandy' + (''+Math.random()).replace(/\D/g, ''),
    
27. addListener = w3c ?
    
28. function(el, type, fn) { el.addEventListener(type, fn, false); } :
    
29. function(el, type, fn) { el.attachEvent('on' + type, fn); },
    
30. removeListener = w3c ?
    
31. function(el, type, fn) { el.removeEventListener(type, fn, false); } :
    
32. function(el, type, fn) { el.detachEvent('on' + type, fn); };
    
33. dispatch = w3c ?
    
34. function( el, type ){
    
35. try{
    
36. var evt = doc.createEvent('Event');
    
37. evt.initEvent( type, true, true );
    
38. el.dispatchEvent( evt );
    
39. }catch( e ){ alert( e ) };
    
40. } :
    
41. function( el, type ){
    
42. try{
    
43. el.fireEvent( 'on' + type );
    
44. }catch( e ){ alert( e ); }
    
45. },
    
46. dataManager = {
    
47. data : function ( elem, name, data ) {
    
48. var getByName = typeof name === "string",
    
49. thisCache,
    
50. isNode = elem.nodeType,
    
51. cache = isNode ? globalCache : elem,
    
52. id = isNode ? elem[ expando ] : elem[ expando ] && expando;
    
53. if(!id && isNode) {
    
54. elem[expando] = id = ++uuid;
    
55. }
    
56. if(!cache[id]){
    
57. cache[id] = {};
    
58. }
    
59. thisCache = cache[id];
    
60. if(data !== undefined) {
    
61. thisCache[name] = data;
    
62. }
    
63. return getByName ? thisCache[name] : thisCache;
    
64. },
    
65. removeData : function ( elem, name ) {
    
66. var id = elem[expando],
    
67. thisCache = globalCache[id];
    
68. if(!id || !thisCache){
    
69. return;
    
70. }
    
71. if(typeof name === 'string') {
    
72. delete thisCache[name];
    
73. }else{
    
74. delete globalCache[id];
    
75. }
    
76. }
    
77. };
    
78. function returnFalse() {
    
79. return false;
    
80. }
    
81. function returnTrue() {
    
82. return true;
    
83. }
    
84. function now() {
    
85. return (new Date).getTime();
    
86. }
    
87. function isEmptyObject( obj ){
    
88. for( var i in obj ){
    
89. return false;
    
90. }
    
91. return true;
    
92. }
    
93. function addEvent (elem, types, handler, data) {
    
94. if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
    
95. return;
    
96. }
    
97. if ( handler === false ) {
    
98. handler = returnFalse;
    
99. } else if ( !handler ) {
    
100. return;
     
101. }
     
102. var elemData = dataManager.data( elem ),
     
103. events = elemData.events,
     
104. eventHandle = elemData.handle,
     
105. types = types.split(" ");
     
106. if ( !events ) {
     
107. elemData.events = events = {};
     
108. }
     
109. if ( !eventHandle ) {
     
110. elemData.handle = eventHandle = function ( e ) {
     
111. return evtHandle.call( eventHandle.elem, e );
     
112. };
     
113. }
     
114. eventHandle.elem = elem;
     
115. var type, i = 0;
     
116. while ( type = types[i++] ) {
     
117. var handleObj = {handler : handler, data : data},
     
118. handlers = events[type];
     
119. if ( !handlers ) {
     
120. handlers = events[type] = [];
     
121. addListener( elem, type, eventHandle );
     
122. }
     
123. handlers.push( handleObj );
     
124. }
     
125. elem = null;
     
126. }
     
127. function evtHandle ( event ) {
     
128. event = fixEvent( event || window.event );
     
129. var handlers = ((dataManager.data(this, "events") || {})[event.type] || []).slice(0);
     
130. event.currentTarget = this;
     
131. for( var j = 0, l = handlers.length; j < l; j++ ) {
     
132. var handleObj = handlers[j];
     
133. event.handler = handleObj.handler;
     
134. event.data = handleObj.data;
     
135. event.handleObj = handleObj;
     
136. var ret = handleObj.handler.call( this, event );
     
137. if( ret !== undefined ) {
     
138. if( ret === false ) {
     
139. event.preventDefault();
     
140. event.stopPropagation();
     
141. }
     
142. }
     
143. if( event.isImmediatePropagationStopped() ) {
     
144. break;
     
145. }
     
146. }
     
147. }
     
148. function removeEvent( elem, types, handler ) {
     
149. // don't do events on text and comment nodes
     
150. if( elem.nodeType === 3 || elem.nodeType === 8 ) {
     
151. return;
     
152. }
     
153. if( handler === false ) {
     
154. handler = returnFalse;
     
155. }
     
156. var type, origType, i = 0, j,
     
157. elemData = dataManager.data( elem ),
     
158. events = elemData && elemData.events;
     
159. if( !elemData || !events ) {
     
160. return;
     
161. }
     
162. // Unbind all events for the element
     
163. if( !types ) {
     
164. types = types || "";
     
165. for ( type in events ) {
     
166. removeEvent( elem, type );
     
167. }
     
168. return;
     
169. }
     
170. // Handle multiple events separated by a space
     
171. // jQuery(...).unbind("mouseover mouseout", fn);
     
172. types = types.split(" ");
     
173. while( (type = types[ i++ ]) ) {
     
174. origType = type;
     
175. handleObj = null;
     
176. eventType = events[ type ];
     
177. if( !eventType ) {
     
178. continue;
     
179. }
     
180. if( !handler ) {
     
181. for ( j = 0; j < eventType.length; j++ ) {
     
182. handleObj = eventType[ j ];
     
183. removeEvent( elem, origType, handleObj.handler );
     
184. eventType.splice( j--, 1 );
     
185. }
     
186. continue;
     
187. }
     
188. for( j = 0; j < eventType.length; j++ ) {
     
189. handleObj = eventType[ j ];
     
190. if( handler === handleObj.handler ) {
     
191. // remove the given handler for the given type
     
192. eventType.splice( j--, 1 );
     
193. }
     
194. }
     
195. }
     
196. // remove generic event handler if no more handlers exist
     
197. if ( eventType.length === 0 ) {
     
198. delete events[ origType ];
     
199. }
     
200. // Remove the expando if it's no longer used
     
201. if ( isEmptyObject( events ) ) {
     
202. var handle = elemData.handle;
     
203. if ( handle ) {
     
204. handle.elem = null;
     
205. }
     
206. delete elemData.events;
     
207. delete elemData.handle;
     
208. if ( isEmptyObject( elemData ) ) {
     
209. dataManager.removeData( elem, 'events' );
     
210. }
     
211. }
     
212. }
     
213. function Event( src ) {
     
214. this.originalEvent = src;
     
215. this.type = src.type;
     
216. this.timeStamp = now();
     
217. }
     
218. Event.prototype = {
     
219. preventDefault: function() {
     
220. this.isDefaultPrevented = returnTrue;
     
221. var e = this.originalEvent;
     
222. if( e.preventDefault ) {
     
223. e.preventDefault();
     
224. }
     
225. e.returnValue = false;
     
226. },
     
227. stopPropagation: function() {
     
228. this.isPropagationStopped = returnTrue;
     
229. var e = this.originalEvent;
     
230. if( e.stopPropagation ) {
     
231. e.stopPropagation();
     
232. }
     
233. e.cancelBubble = true;
     
234. },
     
235. stopImmediatePropagation: function() {
     
236. this.isImmediatePropagationStopped = returnTrue;
     
237. this.stopPropagation();
     
238. },
     
239. isDefaultPrevented: returnFalse,
     
240. isPropagationStopped: returnFalse,
     
241. isImmediatePropagationStopped: returnFalse
     
242. };
     
243. function fixEvent( evt ) {
     
244. var props = "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY originalTarget pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
     
245. len = props.length;
     
246. var originalEvent = evt;
     
247. evt = new Event(originalEvent);
     
248. for(var i = len, prop; i;) {
     
249. prop = props[ --i ];
     
250. evt[ prop ] = originalEvent[ prop ];
     
251. }
     
252. if(!evt.target) {
     
253. evt.target = evt.srcElement || document;
     
254. }
     
255. if( evt.target.nodeType === 3 ) {
     
256. evt.target = evt.target.parentNode;
     
257. }
     
258. if( !evt.relatedTarget && evt.fromElement ) {
     
259. evt.relatedTarget = evt.fromElement === evt.target ? evt.toElement : evt.fromElement;
     
260. }
     
261. if( evt.pageX == null && evt.clientX != null ) {
     
262. var doc = document.documentElement, body = document.body;
     
263. evt.pageX = evt.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
     
264. evt.pageY = evt.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);
     
265. }
     
266. if( !evt.which && ((evt.charCode || evt.charCode === 0) ? evt.charCode : evt.keyCode) ) {
     
267. evt.which = evt.charCode || evt.keyCode;
     
268. }
     
269. if( !evt.metaKey && evt.ctrlKey ) {
     
270. evt.metaKey = evt.ctrlKey;
     
271. }
     
272. if( !evt.which && evt.button !== undefined ) {
     
273. evt.which = (evt.button & 1 ? 1 : ( evt.button & 2 ? 3 : ( evt.button & 4 ? 2 : 0 ) ));
     
274. }
     
275. return evt;
     
276. }
     
277. function bind ( el, type, fn, data ) {
     
278. var handler;
     
279. if( typeof type === "object" ) {
     
280. for( var key in type ) {
     
281. bind(el, key, type[key], data);
     
282. }
     
283. return;
     
284. }
     
285. handler = fn;
     
286. addEvent( el, type, handler, data );
     
287. }
     
288. function unbind ( el, type, fn ) {
     
289. if( typeof type === "object" ) {
     
290. for ( var key in type ) {
     
291. unbind( el, key, type[key] );
     
292. }
     
293. }else {
     
294. removeEvent( el, type, fn );
     
295. }
     
296. }
     
297. return {
     
298. data : dataManager.data,
     
299. removeData : dataManager.removeData,
     
300. bind : bind,
     
301. unbind : unbind
     
302. };
     
303. }(this);

复制代码