解决困扰多年的问题：Javascript事件机制兼容性解决方案

本文的解决方案可以用于Javascript native对象和宿主对象（dom元素），通过以下的方式来绑定和触发事件：

或者

1. var input = document.getElementsByTagName('input')[0];  
2. var form = document.getElementsByTagName('form')[0];  
3. Evt.on(input, 'click', function(evt){  
4.     console.log('input click1');  
5.     console.log(evt.target === input);  
6.     console.log(evt.modified);  
7.     //evt.stopPropagation();
8.     console.log(evt.modified);  
9. });  
10. var handle2 = Evt.on(input, 'click', function(evt){  
11.     console.log('input click2');  
12.     console.log(evt.target === input);  
13.     console.log(evt.modified);  
14. });  
15. Evt.on(form, 'click', function(evt){  
16.     console.log('form click');  
17.     console.log(evt.currentTarget === input);  
18.     console.log(evt.target === input);  
19.     console.log(evt.currentTarget === form);  
20.     console.log(evt.modified);  
21. });  
22. Evt.emit(input, 'click');  
23. Evt.emit(input, 'click', {bubbles: true});  
24. handle2.remove();  
25. Evt.emit(input, 'click'); 

After函数

 

为native对象添加事件的过程主要在after函数中完成，这个函数主要做了以下几件事：

1. 如果obj中已有响应函数，将其替换成dispatcher函数
2. 使用链式结构，保证多次绑定事件函数的顺序执行
3. 返回一个handle对象，调用remove方法可以去除本次事件绑定

下图为after函数调用前后onlog函数的引用

 

（调用前）

（调用后）

详细解释请看注释，希望读者能够跟着运行一遍

1. var after = function(target, method, cb, originalArgs){  
2.     var existing = target[method];  
3.     var dispatcher = existing;  
4.     if (!existing || existing.target !== target) {  
5.         //如果target中没有method方法，则为他添加一个方法method方法
6.         //如果target已经拥有method方法，但target[method]中target不符合要求则将method方法他替换
7.         dispatcher = target[method] = function(){  
8.             //由于js是此法作用域：通过阅读包括变量定义在内的数行源码就能知道变量的作用域。
9.             //局部变量在声明它的函数体内以及其所嵌套的函数内始终是有定义的
10.             //所以在这个函数中可以访问到dispatcher变量
11.             var results = null;  
12.             var args = arguments;  
13.             if (dispatcher.around) {//如果原先拥有method方法，先调用原始method方法
14.                 //此时this关键字指向target所以不用target
15.                 results = dispatcher.around.advice.apply(this, args);  
16.             }  
17.               
18.             if (dispatcher.after) {//如果存在after链则依次访问其中的advice方法
19.                 var _after = dispatcher.after;  
20.                 while(_after && _after.advice) {  
21.                     //如果需要原始参数则传入arguments否则使用上次执行结果作为参数
22.                     args = _after.originalArgs ? arguments : results;  
23.                     results = _after.advice.apply(this, args);  
24.                     _after = _after.next;  
25.                 }  
26.             }  
27.         }  
28.           
29.         if (existing) {  
30.         //函数也是对象，也可以拥有属性跟方法
31.         //这里将原有的method方法放到dispatcher中
32.             dispatcher.around = {  
33.                 advice: function(){  
34.                     return existing.apply(target, arguments);  
35.                 }  
36.             }  
37.         }  
38.         dispatcher.target = target;  
39.     }  
40.       
41.       
42.     var signal = {  
43.         originalArgs: originalArgs,//对于每个cb的参数是否使用最初的arguments
44.         advice: cb,  
45.         remove: function() {  
46.             if (!signal.advice) {  
47.                 return;  
48.             }  
49.             //remove的本质是将cb从函数链中移除，删除所有指向他的链接
50.             var previous = signal.previous;  
51.             var next = signal.next;  
52.             if (!previous && !next) {  
53.                 dispatcher.after = signal.advice = null;  
54.                 dispatcher.target = null;  
55.                 delete dispatcher.after;  
56.             } else if (!next){  
57.                 signal.advice = null;  
58.                 previous.next = null;  
59.                 signal.previous = null;  
60.             } else if (!previous){  
61.                 signal.advice = null;  
62.                 dispatcher.after = next;  
63.                 next.previous = null;  
64.                 signal.next = null;  
65.             } else {  
66.                 signal.advice = null;  
67.                 previous.next = next;  
68.                 next.previous = previous;  
69.                 signal.previous = null;  
70.                 signal.next = null;  
71.             }  
72.         }  
73.     }  
74.       
75.       
76.     var previous = dispatcher.after;  
77.     if (previous) {//将signal加入到链式结构中，处理指针关系
78.         while(previous && previous.next && (previous = previous.next)){};  
79.         previous.next = signal;  
80.         signal.previous = previous;  
81.     } else {//如果是第一次使用调用after方法，则dispatcher的after属性指向signal
82.         dispatcher.after = signal;  
83.     }  
84.       
85.     cb = null;//防止内存泄露
86.     return signal;  
87. } 

解决兼容性

IE浏览器从IE9开始已经支持DOM2事件处理程序，但是对于老版本的ie浏览器，任然使用attachEvent方式来为dom元素添加事件。值得庆幸的是微软已宣布2016年将不再对ie8进行维护，对于广大前端开发者无疑是一个福音。然而在曙光来临之前，仍然需要对那些不支持DOM2级事件处理程序的浏览器进行兼容性处理，通常需要处理以下几点：

1. 多次绑定一个事件，事件处理函数的调用顺序问题
2. 事件处理函数中的this关键字指向问题
3. 标准化event事件对象，支持常用的事件属性

由于使用attachEvent方法添加事件处理函数无法保证事件处理函数的调用顺序，所以我们弃用attachEvent，转而用上文中的after生成的正序链式结构来解决这个问题。

1. //1、统一事件触发顺序
2.     function fixAttach(target, type, listener) {  
3.     debugger;  
4.         var listener = fixListener(listener);  
5.         var method = 'on' + type;  
6.         return after(target, method, listener, true);  
7.     }; 

对于事件处理函数中的this关键字指向，通过闭包即可解决（出处），如：

本文也是通过这种方式解决此问题

1. //1、统一事件触发顺序
2.     function fixAttach(target, type, listener) {  
3.     debugger;  
4.         var listener = fixListener(listener);  
5.         var method = 'on' + type;  
6.         return after(target, method, listener, true);  
7.     };  
8.       
9.     function fixListener(listener) {  
10.         return function(evt){  
11.             //每次调用listenser之前都会调用fixEvent
12.             debugger;  
13.             var e = _fixEvent(evt, this);//this作为currentTarget
14.             if (e && e.cancelBubble && (e.currentTarget !== e.target)){  
15.                 return;  
16.             }  
17.             var results =  listener.call(this, e);  
18.  
19.             if (e && e.modified) {  
20.                 // 在整个函数链执行完成后将lastEvent回归到原始状态，
21.                 //利用异步队列，在主程序执行完后再执行事件队列中的程序代码
22.                 //常规的做法是在emit中判断lastEvent并设为null
23.                 //这充分体现了js异步编程的优势，把变量赋值跟清除代码放在一起，避免逻辑分散，缺点是不符合程序员正常思维方式
24.                 if(!lastEvent){  
25.                     setTimeout(function(){  
26.                         lastEvent = null;  
27.                     });  
28.                 }  
29.                 lastEvent = e;  
30.             }  
31.             return results;  
32.         }  
33.     } 

对于事件对象的标准化，我们需要将ie提供给我们的现有属性转化为标准的事件属性。

1. function _fixEvent(evt, sender){  
2.         if (!evt) {  
3.             evt = window.event;  
4.         }  
5.         if (!evt) { // emit没有传递事件参数，或者通过input.onclick方式调用
6.             return evt;  
7.         }  
8.         if(lastEvent && lastEvent.type && evt.type == lastEvent.type){  
9.         //使用一个全局对象来保证在冒泡过程中访问的是同一个event对象
10.         //chrome中整个事件处理过程event是唯一的
11.             evt = lastEvent;  
12.         }  
13.         var fixEvent = evt;  
14.         // bubbles 和cancelable根据每次emit时手动传入参数设置
15.         fixEvent.bubbles = typeof evt.bubbles !== 'undefined' ? evt.bubbles : false;  
16.         fixEvent.cancelable = typeof evt.cancelable !== 'undefined' ? evt.cancelable : true;  
17.         fixEvent.currentTarget = sender;  
18.         if (!fixEvent.target){ // 多次绑定统一事件，只fix一次
19.             fixEvent.target = fixEvent.srcElement || sender;  
20.               
21.             fixEvent.eventPhase = fixEvent.target === sender ? 2 : 3;  
22.             if (!fixEvent.preventDefault) {  
23.                 fixEvent.preventDefault = _preventDefault;  
24.                 fixEvent.stopPropagation = _stopPropagation;  
25.                 fixEvent.stopImmediatePropagation = _stopImmediatePropagation;  
26.             }  
27.             //参考：http://www.nowamagic.net/javascript/js_EventMechanismInDetail.php
28.             if( fixEvent.pageX == null && fixEvent.clientX != null ) {  
29.                 var doc = document.documentElement, body = document.body;  
30.                 fixEvent.pageX = fixEvent.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);  
31.                 fixEvent.pageY = fixEvent.clientY + (doc && doc.scrollTop  || body && body.scrollTop  || 0) - (doc && doc.clientTop  || body && body.clientTop  || 0);  
32.             }  
33.             if (!fixEvent.relatedTarget && fixEvent.fromEvent) {  
34.                 fixEvent.relatedTarget = fixEvent.fromEvent === fixEvent.target ? fixEvent.toElement : fixEvent.fromElement;  
35.             }  
36.             // 参考: http://www.cnblogs.com/hsapphire/archive/2009/12/18/1627047.html
37.             if (!fixEvent.which && fixEvent.keyCode) {  
38.                 fixEvent.which = fixEvent.keyCode;  
39.             }  
40.         }  
41.           
42.         return fixEvent;  
43.     }  
44.       
45.     function _preventDefault(){  
46.         this.defaultPrevented = true;  
47.         this.returnValue = false;  
48.  
49.         this.modified = true;  
50.     }  
51.       
52.     function _stopPropagation(){  
53.         this.cancelBubble = true;  
54.  
55.         this.modified = true;  
56.     }  
57.       
58.     function _stopImmediatePropagation(){  
59.         this.isStopImmediatePropagation = true;  
60.         this.modified = true;  
61.     } 

在_preventDefault、_stopPropagation、_stopImmediatePropagation三个函数中我们，如果被调用则listener执行完后使用一个变量保存event对象（见fixListener），以便后序事件处理程序根据event对象属性进行下一步处理。stopImmediatePropagation函数，对于这个函数的模拟，我们同样通过闭包来解决。

注意这里不能直接写成这种形式，上文中fixListener也是同样道理。

需要注意一点，我们将event标准化目的还有一点，可以在emit方法中设置参数来控制事件过程，比如：

1. Evt.emit(input, 'click');//不冒泡
2. Evt.emit(input, 'click', {bubbles: true});//冒泡

根据我的测试使用fireEvent方式触发事件，无法设置{bubbles:false}来阻止冒泡，所以这里我们用Javascript来模拟冒泡过程。同时在这个过程中也要保证event对象的唯一性。

1. // 模拟冒泡事件
2.     var sythenticBubble = function(target, type, evt){  
3.         var method = 'on' + type;  
4.         var args = Array.prototype.slice.call(arguments, 2);  
5.         // 保证使用emit触发dom事件时，event的有效性
6.         if ('parentNode' in target) {  
7.             var newEvent = args[0] = {};  
8.             for (var p in evt) {  
9.                 newEvent[p] = evt[p];  
10.             }  
11.               
12.             newEvent.preventDefault = _preventDefault;  
13.             newEvent.stopPropagation = _stopPropagation;  
14.             newEvent.stopImmediatePropagation = _stopImmediatePropagation;  
15.             newEvent.target = target;  
16.             newEvent.type = type;  
17.         }  
18.           
19.         do{  
20.             if (target && target[method]) {  
21.                 target[method].apply(target, args);  
22.             }  
23.         }while(target && (target = target.parentNode) && target[method] && newEvent && newEvent.bubbles);  
24.     }  
25.       
26.     var emit = function(target, type, evt){  
27.         if (target.dispatchEvent && document.createEvent){  
28.             var newEvent = document.createEvent('HTMLEvents');  
29.             newEvent.initEvent(type, evt && !!evt.bubbles, evt && !!evt.cancelable);  
30.             if (evt) {  
31.                 for (var p in evt){  
32.                     if (!(p in newEvent)){  
33.                         newEvent[p] = evt[p];  
34.                     }  
35.                 }  
36.             }  
37.               
38.             target.dispatchEvent(newEvent);  
39.         } /*else if (target.fireEvent) {
40.             target.fireEvent('on' + type);// 使用fireEvent在evt参数中设置bubbles:false无效，所以弃用
41.         } */else {  
42.             return sythenticBubble.apply(on, arguments);  
43.         }  
44.     } 

 

附上完整代码：

1. <!DOCTYPE html>
2. <html>
3. <head>
4. <meta http-equiv="Content-Type" content="text/html;charset=utf-8"/>
5. <meta http-equiv="window-target" content="_top">
6. <title>Writing to Same Doc</title>
7. <script language="JavaScript">
8. var after = function(target, method, cb, originalArgs){  
9.     var existing = target[method];  
10.     var dispatcher = existing;  
11.     if (!existing || existing.target !== target) {  
12.         //如果target中没有method方法，则为他添加一个方法method方法  
13.         //如果target已经拥有method方法，但target[method]中target不符合要求则将method方法他替换  
14.         dispatcher = target[method] = function(){  
15.             //由于js是此法作用域：通过阅读包括变量定义在内的数行源码就能知道变量的作用域。  
16.             //局部变量在声明它的函数体内以及其所嵌套的函数内始终是有定义的  
17.             //所以在这个函数中可以访问到dispatcher变量  
18.             var results = null;  
19.             var args = arguments;  
20.             if (dispatcher.around) {//如果原先拥有method方法，先调用原始method方法  
21.                 //此时this关键字指向target所以不用target  
22.                 results = dispatcher.around.advice.apply(this, args);  
23.             }  
24.               
25.             if (dispatcher.after) {//如果存在after链则依次访问其中的advice方法  
26.                 var _after = dispatcher.after;  
27.                 while(_after && _after.advice) {  
28.                     //如果需要原始参数则传入arguments否则使用上次执行结果作为参数  
29.                     args = _after.originalArgs ? arguments : results;  
30.                     results = _after.advice.apply(this, args);  
31.                     _after_after = _after.next;  
32.                 }  
33.             }  
34.         }  
35.           
36.         if (existing) {  
37.         //函数也是对象，也可以拥有属性跟方法  
38.         //这里将原有的method方法放到dispatcher中  
39.             dispatcher.around = {  
40.                 advice: function(){  
41.                     return existing.apply(target, arguments);  
42.                 }  
43.             }  
44.         }  
45.         dispatcher.target = target;  
46.     }  
47.       
48.       
49.     var signal = {  
50.         originalArgs: originalArgs,//对于每个cb的参数是否使用最初的arguments  
51.         advice: cb,  
52.         remove: function() {  
53.             if (!signal.advice) {  
54.                 return;  
55.             }  
56.             //remove的本质是将cb从函数链中移除，删除所有指向他的链接  
57.             var previous = signal.previous;  
58.             var next = signal.next;  
59.             if (!previous && !next) {  
60.                 dispatcher.after = signal.advice = null;  
61.                 dispatcher.target = null;  
62.                 delete dispatcher.after;  
63.             } else if (!next){  
64.                 signal.advice = null;  
65.                 previous.next = null;  
66.                 signal.previous = null;  
67.             } else if (!previous){  
68.                 signal.advice = null;  
69.                 dispatcher.after = next;  
70.                 next.previous = null;  
71.                 signal.next = null;  
72.             } else {  
73.                 signal.advice = null;  
74.                 previous.next = next;  
75.                 next.previous = previous;  
76.                 signal.previous = null;  
77.                 signal.next = null;  
78.             }  
79.         }  
80.     }  
81.       
82.       
83.     var previous = dispatcher.after;  
84.     if (previous) {//将signal加入到链式结构中，处理指针关系  
85.         while(previous && previous.next && (previousprevious = previous.next)){};  
86.         previous.next = signal;  
87.         signal.previous = previous;  
88.     } else {//如果是第一次使用调用after方法，则dispatcher的after属性指向signal  
89.         dispatcher.after = signal;  
90.     }  
91.       
92.     cb = null;//防止内存泄露  
93.     return signal;  
94. }  
95.  
96. //1、统一事件触发顺序  
97. //2、标准化事件对象  
98. //3、模拟冒泡 emit时保持冒泡行为，注意input.onclick这种方式是不冒泡的  
99. //4、保持冒泡过程中event的唯一性  
100.  
101. window.Evt = (function(){  
102.     var on = function(target, type, listener){  
103.     debugger;  
104.         if (!listener){  
105.             return;  
106.         }  
107.         // 处理stopImmediatePropagation，通过包装listener来支持stopImmediatePropagation  
108.         if (!(window.Event && window.Event.prototype && window.Event.prototype.stopImmediatePropagation)) {  
109.             listener = _addStopImmediate(listener);  
110.         }  
111.       
112.         if (target.addEventListener) {  
113.             target.addEventListener(type, listener, false);  
114.               
115.             return {  
116.                 remove: function(){  
117.                     target.removeEventListener(type, listener);  
118.                 }  
119.             }  
120.         } else {  
121.             return fixAttach(target, type, listener);  
122.         }  
123.     };  
124.     var lastEvent; // 使用全局变量来保证一个元素的多个listenser中事件对象的一致性，冒泡过程中事件对象的一致性；在chrome这些过程中使用的是同一个event  
125.     //1、统一事件触发顺序  
126.     function fixAttach(target, type, listener) {  
127.     debugger;  
128.         var listener = fixListener(listener);  
129.         var method = 'on' + type;  
130.         return after(target, method, listener, true);  
131.     };  
132.       
133.     function fixListener(listener) {  
134.         return function(evt){  
135.             //每次调用listenser之前都会调用fixEvent  
136.             debugger;  
137.             var e = _fixEvent(evt, this);//this作为currentTarget  
138.             if (e && e.cancelBubble && (e.currentTarget !== e.target)){  
139.                 return;  
140.             }  
141.             var results =  listener.call(this, e);  
142.  
143.             if (e && e.modified) {  
144.                 // 在整个函数链执行完成后将lastEvent回归到原始状态，  
145.                 //利用异步队列，在主程序执行完后再执行事件队列中的程序代码  
146.                 //常规的做法是在emit中判断lastEvent并设为null  
147.                 //这充分体现了js异步编程的优势，把变量赋值跟清除代码放在一起，避免逻辑分散，缺点是不符合程序员正常思维方式  
148.                 if(!lastEvent){  
149.                     setTimeout(function(){  
150.                         lastEvent = null;  
151.                     });  
152.                 }  
153.                 lastEvent = e;  
154.             }  
155.             return results;  
156.         }  
157.     }  
158.       
159.     function _fixEvent(evt, sender){  
160.         if (!evt) {  
161.             evt = window.event;  
162.         }  
163.         if (!evt) { // emit没有传递事件参数，或者通过input.onclick方式调用  
164.             return evt;  
165.         }  
166.         if(lastEvent && lastEvent.type && evt.type == lastEvent.type){  
167.         //使用一个全局对象来保证在冒泡过程中访问的是同一个event对象  
168.         //chrome中整个事件处理过程event是唯一的  
169.             evt = lastEvent;  
170.         }  
171.         var fixEvent = evt;  
172.         // bubbles 和cancelable根据每次emit时手动传入参数设置  
173.         fixEvent.bubbles = typeof evt.bubbles !== 'undefined' ? evt.bubbles : false;  
174.         fixEvent.cancelable = typeof evt.cancelable !== 'undefined' ? evt.cancelable : true;  
175.         fixEvent.currentTarget = sender;  
176.         if (!fixEvent.target){ // 多次绑定统一事件，只fix一次  
177.             fixEventfixEvent.target = fixEvent.srcElement || sender;  
178.               
179.             fixEventfixEvent.eventPhase = fixEvent.target === sender ? 2 : 3;  
180.             if (!fixEvent.preventDefault) {  
181.                 fixEvent.preventDefault = _preventDefault;  
182.                 fixEvent.stopPropagation = _stopPropagation;  
183.                 fixEvent.stopImmediatePropagation = _stopImmediatePropagation;  
184.             }  
185.             //参考：http://www.nowamagic.net/javascript/js_EventMechanismInDetail.php  
186.             if( fixEvent.pageX == null && fixEvent.clientX != null ) {  
187.                 var doc = document.documentElement, body = document.body;  
188.                 fixEventfixEvent.pageX = fixEvent.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);  
189.                 fixEventfixEvent.pageY = fixEvent.clientY + (doc && doc.scrollTop  || body && body.scrollTop  || 0) - (doc && doc.clientTop  || body && body.clientTop  || 0);  
190.             }  
191.             if (!fixEvent.relatedTarget && fixEvent.fromEvent) {  
192.                 fixEventfixEvent.relatedTarget = fixEvent.fromEvent === fixEvent.target ? fixEvent.toElement : fixEvent.fromElement;  
193.             }  
194.             // 参考: http://www.cnblogs.com/hsapphire/archive/2009/12/18/1627047.html  
195.             if (!fixEvent.which && fixEvent.keyCode) {  
196.                 fixEventfixEvent.which = fixEvent.keyCode;  
197.             }  
198.         }  
199.           
200.         return fixEvent;  
201.     }  
202.       
203.     function _preventDefault(){  
204.         this.defaultPrevented = true;  
205.         this.returnValue = false;  
206.  
207.         this.modified = true;  
208.     }  
209.       
210.     function _stopPropagation(){  
211.         this.cancelBubble = true;  
212.  
213.         this.modified = true;  
214.     }  
215.       
216.     function _stopImmediatePropagation(){  
217.         this.isStopImmediatePropagation = true;  
218.         this.modified = true;  
219.     }  
220.       
221.     function _addStopImmediate(listener) {  
222.         return function(evt) { // 除了包装listener外，还要保证所有的事件函数共用一个evt对象  
223.             if (!evt.isStopImmediatePropagation) {  
224.                 //evt.stopImmediatePropagation = _stopImmediateProgation;  
225.                 return listener.apply(this, arguments);  
226.             }  
227.         }  
228.     }  
229.       
230.     // 模拟冒泡事件  
231.     var sythenticBubble = function(target, type, evt){  
232.         var method = 'on' + type;  
233.         var args = Array.prototype.slice.call(arguments, 2);  
234.         // 保证使用emit触发dom事件时，event的有效性  
235.         if ('parentNode' in target) {  
236.             var newEvent = args[0] = {};  
237.             for (var p in evt) {  
238.                 newEvent[p] = evt[p];  
239.             }  
240.               
241.             newEvent.preventDefault = _preventDefault;  
242.             newEvent.stopPropagation = _stopPropagation;  
243.             newEvent.stopImmediatePropagation = _stopImmediatePropagation;  
244.             newEvent.target = target;  
245.             newEvent.type = type;  
246.         }  
247.           
248.         do{  
249.             if (target && target[method]) {  
250.                 target[method].apply(target, args);  
251.             }  
252.         }while(target && (targettarget = target.parentNode) && target[method] && newEvent && newEvent.bubbles);  
253.     }  
254.       
255.     var emit = function(target, type, evt){  
256.         if (target.dispatchEvent && document.createEvent){  
257.             var newEvent = document.createEvent('HTMLEvents');  
258.             newEvent.initEvent(type, evt && !!evt.bubbles, evt && !!evt.cancelable);  
259.             if (evt) {  
260.                 for (var p in evt){  
261.                     if (!(p in newEvent)){  
262.                         newEvent[p] = evt[p];  
263.                     }  
264.                 }  
265.             }  
266.               
267.             target.dispatchEvent(newEvent);  
268.         } /*else if (target.fireEvent) {  
269.             target.fireEvent('on' + type);// 使用fireEvent在evt参数中设置bubbles:false无效，所以弃用  
270.         } */else {  
271.             return sythenticBubble.apply(on, arguments);  
272.         }  
273.     }  
274.       
275.     return {  
276.         on: on,  
277.         emit: emit  
278.     };  
279. })()  
280. </script>
281. <style type="text/css"></style>
282. </head>
283. <body>
284.   <form>
285.     <input type="button" value="Replace Content" >
286.   </form>
287. </body>
288. </html>

脑图：

 

（点击进入脑图界面）

(文/  木的树 博客园)