js事件委托

合集下载

js中的事件委托(事件代理)详解

js中的事件委托(事件代理)详解

js中的事件委托(事件代理)详解本⽂转载:js中的事件冒泡、事件委托是js 中⼀些需要注意的⼩知识点,这⾥结合转载⽂章总结⼀下:事件冒泡:JS中当出发某些具有冒泡性质的事件是,⾸先在触发元素寻找是否有相应的注册事件,如果没有再继续向上级⽗元素寻找是否有相应的注册事件作出相应,这就是事件冒泡。

事件委托:利⽤事件冒泡的特性,将本应该注册在⼦元素上的处理事件注册在⽗元素上,这样点击⼦元素时发现其本⾝没有相应事件就到⽗元素上寻找作出相应。

这样做的优势有:1.减少DOM操作,提⾼性能。

2.随时可以添加⼦元素,添加的⼦元素会⾃动有相应的处理事件。

转载⽂章内容:起因:1、这是前端⾯试的经典题型,要去找⼯作的⼩伙伴看看还是有帮助的;2、其实我⼀直都没弄明⽩,写这个⼀是为了备忘,⼆是给其他的知其然不知其所以然的⼩伙伴们以参考;概述:那什么叫事件委托呢?它还有⼀个名字叫事件代理,JavaScript⾼级程序设计上讲:事件委托就是利⽤事件冒泡,只指定⼀个事件处理程序,就可以管理某⼀类型的所有事件。

那这是什么意思呢?⽹上的各位⼤⽜们讲事件委托基本上都⽤了同⼀个例⼦,就是取快递来解释这个现象,我仔细揣摩了⼀下,这个例⼦还真是恰当,我就不去想别的例⼦来解释了,借花献佛,我摘过来,⼤家认真领会⼀下事件委托到底是⼀个什么原理:有三个同事预计会在周⼀收到快递。

为签收快递,有两种办法:⼀是三个⼈在公司门⼝等快递;⼆是委托给前台MM代为签收。

现实当中,我们⼤都采⽤委托的⽅案(公司也不会容忍那么多员⼯站在门⼝就为了等快递)。

前台MM收到快递后,她会判断收件⼈是谁,然后按照收件⼈的要求签收,甚⾄代为付款。

这种⽅案还有⼀个优势,那就是即使公司⾥来了新员⼯(不管多少),前台MM也会在收到寄给新员⼯的快递后核实并代为签收。

这⾥其实还有2层意思的:第⼀,现在委托前台的同事是可以代为签收的,即程序中的现有的dom节点是有事件的;第⼆,新员⼯也是可以被前台MM代为签收的,即程序中新添加的dom节点也是有事件的。

JavaScript中的事件委托和事件冒泡

JavaScript中的事件委托和事件冒泡

JavaScript中的事件委托和事件冒泡事件委托和事件冒泡是JavaScript中两个重要的概念,用于处理事件的传递和处理。

它们是Web开发中常用的技术,可以提高代码的效率和可维护性。

下面,我将详细介绍这两个概念以及它们的应用。

一、事件冒泡1.1事件冒泡概述事件冒泡是指当一个HTML元素上的事件被触发时,事件将从最内层元素开始冒泡传递到最外层元素。

例如,当用户点击了一个按钮,点击事件将被触发,然后事件冒泡就会开始,逐级传递到父元素,直到传递到document对象。

1.2事件冒泡的实现事件冒泡是由浏览器自动实现的,并且是默认行为。

通过在JavaScript中使用addEventListener函数绑定事件处理程序,事件冒泡就可以被触发。

例如,以下是一个HTML代码片段,演示了事件冒泡的基本原理:```html<div id="container"><button id="btn">Click Me</button></div>``````javascriptdocument.getElementById("container").addEventListener("cl ick", function() {alert("Container clicked");});document.getElementById("btn").addEventListener("click", function() {alert("Button clicked");});```当用户点击按钮时,首先会触发按钮的点击事件处理程序,弹出"Button clicked"的提示框,然后事件冒泡开始,最终会触发容器元素的点击事件处理程序,弹出"Container clicked"的提示框。

JavaScript事件委托高效应用知识点

JavaScript事件委托高效应用知识点

JavaScript事件委托高效应用知识点JavaScript事件委托是一种常用的优化技术,通过将事件监听器绑定在父元素上,利用事件冒泡机制来处理子元素上的事件,从而减少页面中事件处理程序的数量。

本文将介绍JavaScript事件委托的概念、应用场景以及使用方法等相关知识点。

一、什么是JavaScript事件委托JavaScript事件委托是一种利用事件冒泡原理来实现事件处理的技术。

传统的事件处理方式是直接将事件监听器绑定在每个子元素上,但是当页面元素较多时,会导致大量的事件处理程序存在于页面中,进而影响性能。

而利用事件委托,我们可以将事件监听器绑定在父元素上,通过事件冒泡机制来触发处理。

二、为什么要使用JavaScript事件委托使用JavaScript事件委托可以有效减少页面中的事件处理程序数量,提高页面的性能。

当页面中的子元素较多时,使用事件委托可以使代码更加简洁,维护更加方便。

此外,事件委托还可以实现动态绑定事件处理程序的效果,即使在后续添加的子元素上同样可以触发相应事件的处理。

三、JavaScript事件委托的应用场景1. 列表/表格中的事件处理:在一个由多个子元素组成的列表或表格中,使用事件委托可以方便地添加和删除子元素,而无需重新绑定事件监听器。

2. 动态载入内容:通过Ajax或其他方式动态地向页面添加内容时,使用事件委托可以确保新添加的元素上的事件能够被正确处理。

3. 提高性能要求的情况:当页面的性能要求较高时,使用事件委托可以减少事件处理程序的数量,提高页面的响应速度。

四、JavaScript事件委托的使用方法在使用JavaScript事件委托时,需要进行以下步骤:1. 找到合适的父元素:根据实际情况,找到合适的父元素来绑定事件监听器。

通常选择父元素是存在于页面中且对应的子元素上需要监听的事件相同的元素。

2. 判断事件源:在父元素上绑定事件监听器,通过事件对象的target属性来获取实际触发事件的子元素。

JavaScript中的事件委托和事件冒泡

JavaScript中的事件委托和事件冒泡

JavaScript中的事件委托和事件冒泡事件委托和事件冒泡是JavaScript中常用的两种事件处理机制,它们在Web开发中发挥着重要的作用。

本文将分别介绍事件委托和事件冒泡的概念、原理、使用场景,以及它们之间的关系和区别,帮助读者更好地理解和应用这两种事件处理机制。

事件委托事件委托是一种利用事件冒泡机制,将事件处理程序绑定在父元素上,通过事件冒泡的方式来处理子元素的事件。

简单来说,就是将事件处理程序委托给父元素来统一处理子元素的事件。

这种做法的好处在于可以减少事件处理程序的数量,提高性能,同时能够动态处理新增或删除的子元素。

事件委托的原理是利用事件冒泡机制,在子元素上触发事件后,事件会冒泡到父元素,如果父元素上有相应的事件处理程序,则执行该处理程序。

通过这一机制,我们可以只在父元素上绑定一个事件处理程序,就能处理多个子元素的事件,从而提高效率。

使用事件委托的场景有很多,其中最常见的就是在处理列表或表格等有大量子元素的情况下。

例如,我们可以将点击事件绑定在整个列表的父元素上,通过判断事件触发的具体子元素来执行不同的操作。

这样一来,无论是新增或删除列表项,都不需要重新绑定事件处理程序,而是由父元素统一处理。

另外,事件委托还可以用于优化动态生成的页面,比如通过Ajax获取数据后动态添加到页面中的元素,可以通过事件委托来处理这些新元素的事件,而不需要重新绑定事件处理程序。

在实际应用中,事件委托的代码通常是这样的:```javascriptconst parent = document.getElementById('parent');parent.addEventListener('click', function (event) {if (event.target.tagName === 'LI') {//处理LI元素的点击事件}});```上面的代码中,我们通过`addEventListener`方法在父元素上绑定了点击事件处理程序,然后通过`event.target`判断触发事件的子元素是不是`LI`元素,从而执行相应的操作。

JavaScript中的事件委托原理

JavaScript中的事件委托原理

JavaScript中的事件委托原理在JavaScript开发中,事件委托是一种常用的技术,它能够有效地优化代码性能,提高用户交互的响应速度。

本文将介绍JavaScript中的事件委托原理以及其在实际开发中的应用。

一、什么是事件委托事件委托是指将事件绑定到父元素上,通过监听父元素来触发子元素的事件。

当用户触发事件时,事件首先冒泡到父元素,然后通过判断事件的目标元素来执行相应的操作。

这种方式可以极大地减少事件绑定的数量,提高页面效率,并且能够处理动态添加或删除的子元素。

二、事件委托的原理在了解事件委托的原理之前,我们先来介绍一下事件冒泡和捕获。

1. 事件冒泡事件冒泡是指当一个元素触发了某个事件,该事件会从元素开始逐级向上冒泡,直到根元素为止。

例如,当点击了一个按钮,按钮的点击事件会依次触发按钮、按钮的父元素、父元素的父元素,以此类推。

2. 事件捕获事件捕获与事件冒泡相反,它是从根元素开始,逐级向下捕获事件。

当一个事件触发时,会先触发根元素上的事件处理程序,然后逐级向下执行。

基于事件冒泡和捕获的原理,事件委托就是利用了事件冒泡的特性。

通过将事件绑定到父元素上,当子元素触发事件时,事件会冒泡到父元素,然后通过判断事件的目标元素来执行相应的操作。

三、事件委托的优点事件委托有以下几个优点:1. 减少事件绑定的数量:通过将事件绑定到父元素上,可以避免给每个子元素都绑定事件,减少代码量,提高代码的可维护性。

2. 动态添加或删除元素:对于动态添加或删除的子元素,使用事件委托可以自动适配,无需重新绑定事件。

3. 提高性能:由于减少了事件绑定的数量,可以节省浏览器内存消耗和提高页面加载速度。

四、事件委托的应用场景事件委托常用于以下几个场景:1. 列表或表格:当有大量的列表或表格需要绑定事件时,使用事件委托可以显著减少代码量。

2. 动态加载元素:当页面中有通过Ajax或其他方式动态加载的元素时,使用事件委托可以自动适配,并且无需重新绑定事件。

JavaScript中的事件委托是什么

JavaScript中的事件委托是什么

JavaScript中的事件委托是什么JavaScript是一种强大的脚本语言,广泛应用于网页开发。

事件委托是JavaScript中一种重要的技术,它可以有效地简化代码,提高性能,改善用户体验。

本文将介绍JavaScript中的事件委托是什么,以及它的使用方法和优势。

一、什么是事件委托在了解事件委托之前,我们需要先了解什么是事件冒泡。

当一个元素上发生一个事件时,如果这个元素已经绑定了该事件的处理函数,那么这个处理函数会被执行。

然而,在事件冒泡的过程中,事件会从内层元素一直冒泡到外层元素。

假设我们有一个父元素包含了多个子元素,如果我们给每个子元素都绑定一个点击事件处理函数,那么当点击子元素时,父元素的事件处理函数也会被触发。

这就是事件冒泡。

基于事件冒泡的原理,事件委托产生了,事件委托的原理是利用事件冒泡机制,将事件绑定在父元素上,通过判断事件的源目标,来触发对应的处理函数。

它的核心思想是利用事件的冒泡原理,将事件的处理交给父元素来统一管理,避免给每个子元素都绑定事件处理函数。

二、事件委托的使用方法事件委托的使用方法非常简单,只需将事件绑定在父元素上,然后通过判断事件的目标来触发相应的处理函数。

下面通过一个例子来演示事件委托的用法。

```javascript// HTML结构<ul id="list"><li>Apple</li><li>Banana</li><li>Orange</li></ul>// JavaScript代码var list = document.getElementById('list');list.addEventListener('click', function(event) {var target = event.target;if (target.nodeName === 'LI') {console.log(target.textContent);}});```上述例子中,我们将点击事件绑定在父元素`<ul>`上,通过判断点击的目标元素是`<li>`,来输出相应的文本内容。

详解js的事件代理(委托)

详解js的事件代理(委托)

详解js的事件代理(委托)JavaScript事件代理(委托)⼀般⽤于以下情况:1. 事件注册在祖先级元素上,代理其⼦级元素。

可以减少事件注册数量,节约内存开销,提⾼性能。

2. 对js动态添加的⼦元素可⾃动绑定事件。

之前⼀直⽤各种js库的事件代理,如 jQuery,⾮常⽅便实⽤。

今天尝试⽤原⽣ js 实现该功能。

var addEvent = (function () {if (document.addEventListener) {return function (element, type, handler) {element.addEventListener(type, handler, false);};} else if (document.attachEvent) {return function (element, type, handler) {element.attachEvent('on' + type, function () {handler.apply(element, arguments);});};} else {return function (element, type, handler) {element['on' + type] = function () {return handler.apply(element, arguments);};};}})(),getClassElements = function (parentElement, classname) {var all, element, classArr = [], classElements = [];if (parentElement.getElementsByClassName) {return parentElement.getElementsByClassName(classname);} else {all = parentElement.getElementsByTagName('*');for (var i = 0, len = all.length; i < len; i++) {element = all[i];classArr = element && element.className && element.className.split(' ');if (classArr) {for (var j = 0; j < classArr.length; j++) {if (classArr[j] === classname) {classElements.push(element);}}}}return classElements;}},delegate = function () { // 参数:element, type, [selector,] handlervar args = arguments,element = args[0],type = args[1],handler;if (args.length === 3) {handler = args[2];return addEvent(element, type, handler);}if (args.length === 4) {selector = args[2];handler = args[3];return addEvent(element, type, function (event) {var event = event || window.event,target = event.target || event.srcElement,quickExpr = /^(?:[a-zA-Z]*#([\w-]+)|(\w+)|[a-zA-Z]*\.([\w-]+))$/,match,idElement,elements,tagName,count = 0,len;if (typeof selector === 'string') {match = quickExpr.exec(selector);if (match) {// #ID selectorif (match[1]) {idElement = document.getElementById(match[1]);tagName = match[0].slice(0, match[0].indexOf('#'));// tag selector} else if (match[2]) {elements = element.getElementsByTagName(selector);// .class selector} else if (match[3]) {elements = getClassElements(element, match[3]);tagName = match[0].slice(0, match[0].indexOf('.'));}}if (idElement) {if ( tagName ? tagName === idElement.nodeName.toLowerCase() && target === idElement : target === idElement ) {return handler.apply(idElement, arguments);}} else if (elements) {for (len = elements.length; count < len; count++) {if ( tagName ? tagName === elements[count].nodeName.toLowerCase() && target === elements[count] : target === elements[count] ) { return handler.apply(elements[count], arguments);}}}}});}};主要是⽤ apply 改变 this 的指向handler.apply(idElement, arguments);handler.apply(elements[count], arguments);测试⼀下:<style>#outer {padding: 50px; background-color: lightpink;}#inner {padding: 30px; background-color: aliceblue;}#paragraph1, #paragraph3 {background-color: cadetblue}</style><div id="outer">outer<div id="inner">inner<p id="paragraph1" class="parag1">paragraph1</p><p id="paragraph2" class="parag">paragraph2</p><span>span</span><p id="paragraph3" class="parag">paragraph3</p></div></div>var outer = document.getElementById('outer');delegate(outer, 'click', function () {console.log(this.id); // outer});delegate(outer, 'click', 'p', function () {console.log(this.id); //点击 paragraph1 元素,输出其id为 "paragraph1"});模仿 jQuery 的风格,优化代码:(function () {var $ = function (element) {return new _$(element);};var _$ = function (element) {this.element = element && element.nodeType === 1 ? element : document;};_$.prototype = {constructor: _$,addEvent: function (type, handler, useCapture) {var element = this.element;if (document.addEventListener) {element.addEventListener(type, handler, (useCapture ? useCapture : false));} else if (document.attachEvent) {element.attachEvent('on' + type, function () {handler.apply(element, arguments);});} else {element['on' + type] = function () {return handler.apply(element, arguments);};}return this;},getClassElements: function (classname) {var element = this.element, all, ele, classArr = [], classElements = [];if (element.getElementsByClassName) {return element.getElementsByClassName(classname);} else {all = element.getElementsByTagName('*');for (var i = 0, len = all.length; i < len; i++) {ele = all[i];classArr = ele && ele.className && ele.className.split(' ');if (classArr) {for (var j = 0; j < classArr.length; j++) {if (classArr[j] === classname) {classElements.push(ele);}}}}return classElements;}},delegate: function () { //参数:type, [selector,] handlervar self = this,element = this.element,type = arguments[0],handler;if (arguments.length === 2) {handler = arguments[1];return self.addEvent(type, handler);} else if (arguments.length === 3) {selector = arguments[1];handler = arguments[2];return self.addEvent(type, function (event) {var event = event || window.event,target = event.target || event.srcElement,quickExpr = /^(?:[a-zA-Z]*#([\w-]+)|(\w+)|[a-zA-Z]*\.([\w-]+))$/,match,idElement,elements,tagName,count = 0,len;if (typeof selector === 'string') {match = quickExpr.exec(selector);if (match) {// #ID selectorif (match[1]) {idElement = document.getElementById(match[1]);tagName = match[0].slice(0, match[0].indexOf('#'));// tag selector} else if (match[2]) {elements = element.getElementsByTagName(selector);// .class selector} else if (match[3]) {elements = self.getClassElements(match[3]);tagName = match[0].slice(0, match[0].indexOf('.'));}}if (idElement) {if ( tagName ? tagName === idElement.nodeName.toLowerCase() && target === idElement ? target === idElement ) {return handler.apply(idElement, arguments);}} else if (elements) {for (len = elements.length; count < len; count++) {if ( tagName ? tagName === elements[count].nodeName.toLowerCase() && target === elements[count] : target === elements[count] ) { return handler.apply(elements[count], arguments);}}}}});}}};window.$ = $;return $;}());使⽤如下:var outer = document.getElementById('outer');$(outer).delegate('click', '.parag', function (event) {console.log(this.id);});以上就是本⽂的全部内容,希望本⽂的内容对⼤家的学习或者⼯作能带来⼀定的帮助,同时也希望多多⽀持!。

对JS中事件委托的理解

对JS中事件委托的理解

对JS中事件委托的理解什么是事件委托:事件委托——给⽗元素绑定事件,⽤来监听⼦元素的冒泡事件,并找到是哪个⼦元素的事件。

(不理解冒泡的可以去百度下)定义:利⽤事件冒泡处理动态元素事件绑定的⽅法,专业术语叫事件委托。

使⽤事件委托技术可以避免对特定的每个节点添加事件监听器,相反,事件监听器是被添加到它们的⽗元素上。

事件监听器会分析从⼦元素冒泡上来的事件,找到是哪个⼦元素的事件。

事件委托的好处:事件委托技术可以避免对每个字元素添加事件监听器,减少操作DOM节点的次数,从⽽减少浏览器的重绘和重排,提⾼代码的性能。

使⽤事件委托,只有⽗元素与DOM存在交互,其他的操作都是在JS虚拟内存中完成的,这样就⼤⼤提⾼了性能。

什么时候⽤事件委托:当⼦元素有很多,需要对⼦元素的时间进⾏监听的时候案例:(1)原⽣JS实现事件委托效果<!DOCTYPE html><html><head><title>事件委托测试</title></head><body><style type="text/css">*{margin: 0;padding: 0;}a{text-decoration: none;}ul,li{list-style: none;}div{display: block;width: 500px;padding: 200px 0 0 200px;}div ul li{display: block;width: 100%;text-align: center;height: 35px;line-height: 35px;}div ul li:nth-child(2n){background: #f00;}</style><div><ul><li><a>测试1</a></li><li><a>测试2</a></li><li><a>测试3</a></li><li><a>测试4</a></li><li><a>测试5</a></li><li><a>测试6</a></li><li><a>测试7</a></li><li><a>测试8</a></li></ul></div><script type="text/javascript">document.getElementsByTagName("ul")[0].addEventListener('click',function(e){alert("点击的内容是:"+e.target.innerHTML);});</script></body></html>事件委托三部曲:第⼀步:给⽗元素绑定事件给元素ul添加绑定事件,通过addEventListener为点击事件click添加绑定第⼆步:监听⼦元素的冒泡事件这⾥默认是冒泡,点击⼦元素li会向上冒泡第三步:找到是哪个⼦元素的事件通过匿名回调函数的参数e⽤来接收事件对象,通过target获取触发事件的⽬标(2)JQ实现事件委托<!DOCTYPE html><html><head><title>事件委托测试</title></head><body><script type="text/javascript" src="https:///jquery/3.0.0/jquery.min.js"></script><style type="text/css">*{margin: 0;padding: 0;}a{text-decoration: none;}ul,li{list-style: none;}div{display: block;width: 500px;padding: 200px 0 0 200px;}div ul li{display: block;width: 100%;text-align: center;height: 35px;line-height: 35px;} div ul li:nth-child(2n){background: #f00;}</style><div><ul><li><a>测试1</a></li><li><a>测试2</a></li><li><a>测试3</a></li><li><a>测试4</a></li><li><a>测试5</a></li><li><a>测试6</a></li><li><a>测试7</a></li><li><a>测试8</a></li></ul></div><script type="text/javascript">$("ul").on('click',function(e){alert("点击的内容是:"+$(e.target).text());});</script></body></html>。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

JavaScript中的事件委托
传统的事件处理
事件委托就是在一个页面上使用一个事件来管理多种类型的事件。

这并不是一个新的想法,但对于把握性能来说却很重要。

通常情况,你会在web应用程序中看到这样的代码:document.getElementById("help-btn").onclick = function(event){ openHelp(); };
document.getElementById("save-btn").onclick = function(event){ saveDocumen t(); };
document.getElementById("undo-btn").onclick = function(event){ undoChanges (); };
这种传统的编码方式给每个元素分配单独的事件处理方法。

对于交互少的站点来说,这样做是可以的。

然而,对于大型的wen应用程序,当存在大量的事件处理的时候,就会显得反应迟钝。

这里要关注的不是速度问题,而是内存占用问题。

如果有数百个交互,DOM元素和JavaScript 代码就会有数百个关联。

web应用需要占用的内存越多,它的响应速度就越慢。

事件委托能将这个问题减小。

事件冒泡及捕获
要不是事件的下面这些属性,事件委托将成为可能。

早期的web开发,浏览器厂商很难回答一个哲学上的问题:当你在页面上的一个区域点击时,你真正感兴趣的是哪个元素。

这个问题带来了交互的定义。

在一个元素的界限内点击,显得有点含糊。

毕竟,在一个元素上的点击同时也发生在另一个元素的界限内。

例如单击一个按钮。

你实际上点击了按钮区域、body元素的区域以及html元素的区域。

伴随着这个问题,两种主流的浏览器Netscape和IE有不同的解决方案。

Netscape定义了一种叫做事件捕获的处理方法,事件首先发生在DOM树的最高层对象(document)然后往最深层的元素传播。

在图例中,事件捕获首先发生在document上,然后是html元素,body元素,最后是button元素。

IE 的处理方法正好相反。

他们定义了一种叫事件冒泡的方法。

事件冒泡认为事件促发的最深层元素首先接收事件。

然后是它的父元素,依次向上,知道 document对象最终接收到事件。

尽管相对于html元素来说,document没有独立的视觉表现,他仍然是html元素的父元素并且事件能冒泡到 document元素。

所以图例中噢噢那个button元素先接收事件,然后是body、html最后是document。

在定义DOM的时候,W3C显然看到了这两种方案各自的优点,所以DOM Level 2的事件规范中同时定义了这两种方案。

首先document元素获得事件,然后捕获阶段向与事件最相关的元素传播,当事件被此元素捕获后,再冒泡到 document元素。

addEventListener()方法接受三个参数:事件名,事件处理函数,一个用于指定事件在捕获阶段处理还是在冒泡阶段处理的布尔值。

大部分的web开发者都会使用false作为第三个参数这样就跟IE中的attachEvent()一样了。

//bubbling phase handler
document.addEventListener("click", handleClick, false);
//capturing phase handler
document.addEventListener("click", handleClick, true);
通过冒泡实现事件委托
事件委托的关键就是在通过冒泡方式实现在最高层(通常是document)处理事件。

不是所有的事件都支持冒泡,但是鼠标和键盘事件支持,并且这也是你所关心的。

回顾下前面的例子,你可以通过在document上分配一个事件来处理所有的单击事件,只需要通过区别节点来决定处理事件的方法。

document.onclick = function(event){
//IE doesn't pass in the event object
event = event || window.event;
//IE uses srcElement as the target
var target = event.target || event.srcElement;
switch(target.id){
case"help-btn":
openHelp();
break;
case"save-btn":
saveDocument();
break;
case"undo-btn":
undoChanges();
break;
//others?
}
};
使用事件委托,数个事件处理函数可以使用一个函数来管理。

所有的单击事件被委托给一个合适的函数来处理。

同样,
mousedown, mouseup, mousemove, mouseover, mouseout, dblclick, keyup, keydown, 和keypress事件也可以这样处理。

但是,在事件委托中mouseover和mouseout的处理方法是不同的,当鼠标从一个元素移动到它的子元素内的时候,被认为是"out"。

注意:你也可以使用事件捕获来完成事件委托,但这只能用在支持事件捕获的非IE浏览器中。

优点
事件委托对于web应用程序的性能有如下几个优点:
1.需要管理的函数变少了
2.占用的内存少了
3.javascript代码和Dom结构之间的关联更少了
4.在改变DOM结构中的innerHTML时,不需要改动事件处理函数
从传统的事件处理方法转向事件委托提高了大型web应用的性能。

正因为它如此的重要,一些类似于YUI、jQuey的javascript库也开始将事件委托应用在它们的核心接口中。

实现事件委托是很轻松的,却能带来性能上很大的提高。

尤其表现在你将数十个事件处理函数整合到一个函数里。

试一下事件委托,你就不会再使用传统的事件处理方法了。

相关文档
最新文档