活动公告

系统通知
通知：关于部分勋章领取条件及购买价格调整的通知
05-18 21:22
系统通知
通知：本站资源由网友上传分享，如有违规等问题请到版务模块进行投诉，资源失效请在帖子内回复要求补档，会尽快处理！
10-23 09:31
>社区 > 科技 > 经验交流 >帖子
本版发帖返回

掌握HTML DOM事件监听添加技巧提升网页交互体验从基础addEventListener到高级事件委托全面解析

这是个蓝孩子 当前离线 威震华夏关云长
SunJu_FaceMall

3万

主题

2860

科技点

3万

积分

白金月票

碾压王

积分
32872

塔罗立华奏
<font color=白金月票" /> 发表于 2025-9-15 12:40:00 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要 登录 才可以下载或查看，没有账号？立即注册

x
引言

在现代网页开发中，交互性是提升用户体验的关键因素。用户与网页的每一次互动，如点击按钮、滚动页面、填写表单等，都是通过DOM事件来实现的。掌握DOM事件监听技术，能够让开发者创建出响应迅速、交互流畅的网页应用。本文将从基础的addEventListener方法开始，逐步深入到高级的事件委托技术，全面解析HTML DOM事件监听的添加技巧，帮助开发者提升网页交互体验。

DOM事件基础

什么是DOM事件

DOM（Document Object Model）事件是用户或浏览器自身执行的某种动作，例如点击、加载、鼠标移动等。这些事件可以被JavaScript监听并作出响应，从而实现交互功能。

事件类型

DOM事件可以分为以下几类：

1. 鼠标事件：click, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout等
2. 键盘事件：keydown, keyup, keypress等
3. 表单事件：submit, change, focus, blur等
4. 文档/窗口事件：load, resize, scroll, unload等
5. 触摸事件：touchstart, touchmove, touchend等（移动设备）

事件流

事件流描述的是从页面中接收事件的顺序。主要有两种事件流模型：

1. 事件冒泡（Event Bubbling）：事件开始时由最具体的元素（文档中嵌套层次最深的那个节点）接收，然后逐级向上传播到较为不具体的节点（文档）。
2. 事件捕获（Event Capturing）：不太具体的节点应该更早接收到事件，而最具体的节点应该最后接收到事件。

addEventListener基础用法

基本语法

addEventListener是DOM元素提供的方法，用于添加事件监听器。其基本语法如下：
  2. element.addEventListener(event, function, useCapture);
复制代码

参数说明：

• event：字符串，表示要监听的事件类型（如”click”、”mouseover”等）
• function：事件触发时执行的函数，也称为事件处理函数
• useCapture：布尔值，可选参数，指定事件是在捕获阶段还是冒泡阶段处理，默认为false（冒泡阶段）

基本示例

下面是一个简单的点击事件监听示例：
  2. <!DOCTYPE html>
  3. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7.     <title>addEventListener基础示例</title>
  8.     <style>
  9.         button {
  10.             padding: 10px 15px;
  11.             font-size: 16px;
  12.             cursor: pointer;
  13.         }
  14.     </style>
  15. </head>
  16. <body>
  17.     <button id="myButton">点击我</button>
  18.     <p id="message"></p>
  20.     <script>
  21.         // 获取按钮元素
  22.         const button = document.getElementById('myButton');
  23.         const message = document.getElementById('message');
  24.         
  25.         // 添加点击事件监听器
  26.         button.addEventListener('click', function() {
  27.             message.textContent = '按钮被点击了！';
  28.         });
  29.     </script>
  30. </body>
  31. </html>
复制代码

在这个示例中，当用户点击按钮时，会触发一个匿名函数，该函数会在页面上显示一条消息。

事件处理函数的多种形式

使用命名函数

除了匿名函数，我们还可以使用命名函数作为事件处理函数：
  2. <!DOCTYPE html>
  3. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7.     <title>命名函数作为事件处理函数</title>
  8.     <style>
  9.         button {
  10.             padding: 10px 15px;
  11.             font-size: 16px;
  12.             cursor: pointer;
  13.         }
  14.     </style>
  15. </head>
  16. <body>
  17.     <button id="myButton">点击我</button>
  18.     <p id="message"></p>
  20.     <script>
  21.         // 获取按钮元素
  22.         const button = document.getElementById('myButton');
  23.         const message = document.getElementById('message');
  24.         
  25.         // 定义命名函数
  26.         function handleClick() {
  27.             message.textContent = '按钮被点击了！';
  28.         }
  29.         
  30.         // 添加点击事件监听器
  31.         button.addEventListener('click', handleClick);
  32.     </script>
  33. </body>
  34. </html>
复制代码

使用命名函数的好处是可以在需要时移除事件监听器，也可以在其他地方重用这个函数。

使用箭头函数

ES6引入的箭头函数也可以作为事件处理函数：
  2. <!DOCTYPE html>
  3. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7.     <title>箭头函数作为事件处理函数</title>
  8.     <style>
  9.         button {
  10.             padding: 10px 15px;
  11.             font-size: 16px;
  12.             cursor: pointer;
  13.         }
  14.     </style>
  15. </head>
  16. <body>
  17.     <button id="myButton">点击我</button>
  18.     <p id="message"></p>
  20.     <script>
  21.         // 获取按钮元素
  22.         const button = document.getElementById('myButton');
  23.         const message = document.getElementById('message');
  24.         
  25.         // 添加点击事件监听器，使用箭头函数
  26.         button.addEventListener('click', () => {
  27.             message.textContent = '按钮被点击了！';
  28.         });
  29.     </script>
  30. </body>
  31. </html>
复制代码

需要注意的是，箭头函数没有自己的this绑定，它会捕获其所在上下文的this值。这在某些情况下可能会导致不同的行为。

带参数的事件处理函数

有时我们需要向事件处理函数传递额外的参数，可以通过以下方式实现：
  2. <!DOCTYPE html>
  3. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7.     <title>带参数的事件处理函数</title>
  8.     <style>
  9.         button {
  10.             padding: 10px 15px;
  11.             margin: 5px;
  12.             font-size: 16px;
  13.             cursor: pointer;
  14.         }
  15.     </style>
  16. </head>
  17. <body>
  18.     <button id="btn1">按钮1</button>
  19.     <button id="btn2">按钮2</button>
  20.     <p id="message"></p>
  22.     <script>
  23.         // 获取按钮元素
  24.         const btn1 = document.getElementById('btn1');
  25.         const btn2 = document.getElementById('btn2');
  26.         const message = document.getElementById('message');
  27.         
  28.         // 定义带参数的函数
  29.         function showMessage(buttonName, event) {
  30.             message.textContent = `${buttonName} 被点击了！`;
  31.             console.log('事件对象:', event);
  32.         }
  33.         
  34.         // 添加点击事件监听器，使用匿名函数包装
  35.         btn1.addEventListener('click', function(event) {
  36.             showMessage('按钮1', event);
  37.         });
  38.         
  39.         // 使用箭头函数包装
  40.         btn2.addEventListener('click', (event) => {
  41.             showMessage('按钮2', event);
  42.         });
  43.     </script>
  44. </body>
  45. </html>
复制代码

事件对象详解

事件对象的属性和方法

当事件被触发时，浏览器会创建一个事件对象，包含与事件相关的信息。这个对象会作为参数传递给事件处理函数。

常用的事件对象属性和方法：

• type：事件类型（如”click”、”mouseover”等）
• target：触发事件的元素
• currentTarget：当前处理事件的元素（通常是添加事件监听器的元素）
• bubbles：布尔值，表示事件是否冒泡
• cancelable：布尔值，表示是否可以取消事件的默认行为
• defaultPrevented：布尔值，表示是否已经调用了preventDefault()
• eventPhase：整数，表示事件处理的阶段（1=捕获，2=目标，3=冒泡）
• timeStamp：事件发生的时间戳
• preventDefault()：取消事件的默认行为
• stopPropagation()：停止事件的传播

事件对象示例
  2. <!DOCTYPE html>
  3. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7.     <title>事件对象示例</title>
  8.     <style>
  9.         #container {
  10.             width: 300px;
  11.             height: 200px;
  12.             background-color: #f0f0f0;
  13.             padding: 20px;
  14.             border: 1px solid #ccc;
  15.         }
  16.         
  17.         #inner {
  18.             width: 150px;
  19.             height: 100px;
  20.             background-color: #e0e0e0;
  21.             padding: 10px;
  22.             border: 1px solid #999;
  23.         }
  24.     </style>
  25. </head>
  26. <body>
  27.     <div id="container">
  28.         外层容器
  29.         <div id="inner">内层元素</div>
  30.     </div>
  31.     <div id="output"></div>
  33.     <script>
  34.         const container = document.getElementById('container');
  35.         const inner = document.getElementById('inner');
  36.         const output = document.getElementById('output');
  37.         
  38.         function logEventInfo(event, elementName) {
  39.             output.innerHTML += `
  40.                 <p><strong>${elementName}</strong> - 事件类型: ${event.type},
  41.                 目标元素: ${event.target.id},
  42.                 当前元素: ${event.currentTarget.id},
  43.                 事件阶段: ${event.eventPhase}</p>
  44.             `;
  45.         }
  46.         
  47.         // 添加事件监听器
  48.         container.addEventListener('click', function(event) {
  49.             logEventInfo(event, '外层容器');
  50.         });
  51.         
  52.         inner.addEventListener('click', function(event) {
  53.             logEventInfo(event, '内层元素');
  54.         });
  55.     </script>
  56. </body>
  57. </html>
复制代码

在这个示例中，点击内层元素时，事件会冒泡到外层容器，两个事件处理函数都会被调用。通过事件对象，我们可以看到事件的目标元素、当前元素以及事件处理的阶段。

事件移除

removeEventListener方法

要移除已添加的事件监听器，可以使用removeEventListener方法。其语法与addEventListener类似：
  2. element.removeEventListener(event, function, useCapture);
复制代码

需要注意的是，要成功移除事件监听器，传递给removeEventListener的参数必须与addEventListener时使用的参数完全相同。这意味着如果使用匿名函数添加事件监听器，将无法移除它。

事件移除示例
  2. <!DOCTYPE html>
  3. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7.     <title>事件移除示例</title>
  8.     <style>
  9.         button {
  10.             padding: 10px 15px;
  11.             margin: 5px;
  12.             font-size: 16px;
  13.             cursor: pointer;
  14.         }
  15.         
  16.         #output {
  17.             margin-top: 20px;
  18.             padding: 10px;
  19.             background-color: #f0f0f0;
  20.             border: 1px solid #ccc;
  21.         }
  22.     </style>
  23. </head>
  24. <body>
  25.     <button id="clickBtn">点击我</button>
  26.     <button id="removeBtn">移除事件监听器</button>
  27.     <div id="output"></div>
  29.     <script>
  30.         const clickBtn = document.getElementById('clickBtn');
  31.         const removeBtn = document.getElementById('removeBtn');
  32.         const output = document.getElementById('output');
  33.         let clickCount = 0;
  34.         
  35.         // 定义命名函数作为事件处理函数
  36.         function handleClick() {
  37.             clickCount++;
  38.             output.textContent = `按钮被点击了 ${clickCount} 次`;
  39.         }
  40.         
  41.         // 添加事件监听器
  42.         clickBtn.addEventListener('click', handleClick);
  43.         
  44.         // 添加移除事件监听器的按钮
  45.         removeBtn.addEventListener('click', function() {
  46.             clickBtn.removeEventListener('click', handleClick);
  47.             output.textContent = `事件监听器已移除。按钮被点击了 ${clickCount} 次`;
  48.         });
  49.     </script>
  50. </body>
  51. </html>
复制代码

在这个示例中，我们使用命名函数handleClick作为事件处理函数，这样就可以在需要时通过removeEventListener移除它。

事件冒泡与捕获

事件流阶段

DOM2级事件规定事件流包括三个阶段：

1. 事件捕获阶段：事件从document对象向下传播到目标元素
2. 目标阶段：事件到达目标元素
3. 事件冒泡阶段：事件从目标元素向上传播回document对象

控制事件流

通过addEventListener的第三个参数useCapture，我们可以控制事件是在捕获阶段还是冒泡阶段处理：
  2. // 在捕获阶段处理事件
  3. element.addEventListener(event, handler, true);
  5. // 在冒泡阶段处理事件（默认）
  6. element.addEventListener(event, handler, false);
  7. element.addEventListener(event, handler); // 默认为false
复制代码

事件冒泡与捕获示例
  2. <!DOCTYPE html>
  3. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7.     <title>事件冒泡与捕获示例</title>
  8.     <style>
  9.         #outer {
  10.             width: 300px;
  11.             height: 200px;
  12.             background-color: #f0f0f0;
  13.             padding: 20px;
  14.             border: 1px solid #ccc;
  15.             position: relative;
  16.         }
  17.         
  18.         #middle {
  19.             width: 200px;
  20.             height: 120px;
  21.             background-color: #d0d0d0;
  22.             padding: 15px;
  23.             border: 1px solid #999;
  24.             position: absolute;
  25.             top: 30px;
  26.             left: 30px;
  27.         }
  28.         
  29.         #inner {
  30.             width: 100px;
  31.             height: 60px;
  32.             background-color: #b0b0b0;
  33.             padding: 10px;
  34.             border: 1px solid #777;
  35.             position: absolute;
  36.             top: 20px;
  37.             left: 20px;
  38.             text-align: center;
  39.             line-height: 40px;
  40.             cursor: pointer;
  41.         }
  42.         
  43.         #output {
  44.             margin-top: 220px;
  45.             padding: 10px;
  46.             background-color: #f9f9f9;
  47.             border: 1px solid #ddd;
  48.             height: 200px;
  49.             overflow-y: auto;
  50.         }
  51.         
  52.         .log-entry {
  53.             margin: 5px 0;
  54.             padding: 5px;
  55.             border-bottom: 1px solid #eee;
  56.         }
  57.         
  58.         .capture {
  59.             color: #0066cc;
  60.         }
  61.         
  62.         .bubble {
  63.             color: #cc6600;
  64.         }
  65.         
  66.         .target {
  67.             color: #009900;
  68.             font-weight: bold;
  69.         }
  70.     </style>
  71. </head>
  72. <body>
  73.     <div id="outer">外层
  74.         <div id="middle">中层
  75.             <div id="inner">内层</div>
  76.         </div>
  77.     </div>
  78.     <div id="output"></div>
  80.     <script>
  81.         const outer = document.getElementById('outer');
  82.         const middle = document.getElementById('middle');
  83.         const inner = document.getElementById('inner');
  84.         const output = document.getElementById('output');
  85.         
  86.         function logEvent(phase, element, event) {
  87.             const logEntry = document.createElement('div');
  88.             logEntry.className = `log-entry ${phase}`;
  89.             logEntry.textContent = `${phase}阶段: ${element} - 事件目标: ${event.target.id}`;
  90.             output.appendChild(logEntry);
  91.         }
  92.         
  93.         // 添加捕获阶段事件监听器
  94.         outer.addEventListener('click', function(event) {
  95.             logEvent('捕获', '外层', event);
  96.         }, true);
  97.         
  98.         middle.addEventListener('click', function(event) {
  99.             logEvent('捕获', '中层', event);
  100.         }, true);
  101.         
  102.         inner.addEventListener('click', function(event) {
  103.             logEvent('捕获', '内层', event);
  104.         }, true);
  105.         
  106.         // 添加冒泡阶段事件监听器
  107.         outer.addEventListener('click', function(event) {
  108.             logEvent('冒泡', '外层', event);
  109.         }, false);
  110.         
  111.         middle.addEventListener('click', function(event) {
  112.             logEvent('冒泡', '中层', event);
  113.         }, false);
  114.         
  115.         inner.addEventListener('click', function(event) {
  116.             logEvent('目标', '内层', event);
  117.         }, false);
  118.     </script>
  119. </body>
  120. </html>
复制代码

在这个示例中，我们在三个嵌套的元素上都添加了捕获阶段和冒泡阶段的事件监听器。当点击最内层的元素时，可以看到事件流的完整过程：先从外到内进行捕获，然后到达目标，最后从内到外进行冒泡。

阻止事件传播

有时我们需要阻止事件的传播，可以使用以下方法：

1. event.stopPropagation()：阻止事件在DOM中传播，但不阻止默认行为
2. event.stopImmediatePropagation()：阻止事件传播，并且阻止同一元素上的其他事件处理函数被调用
3. event.preventDefault()：阻止事件的默认行为，但不阻止事件传播
  2. <!DOCTYPE html>
  3. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7.     <title>阻止事件传播示例</title>
  8.     <style>
  9.         #outer {
  10.             width: 300px;
  11.             height: 200px;
  12.             background-color: #f0f0f0;
  13.             padding: 20px;
  14.             border: 1px solid #ccc;
  15.         }
  16.         
  17.         #inner {
  18.             width: 150px;
  19.             height: 100px;
  20.             background-color: #e0e0e0;
  21.             padding: 10px;
  22.             border: 1px solid #999;
  23.             margin-top: 20px;
  24.             text-align: center;
  25.             line-height: 80px;
  26.             cursor: pointer;
  27.         }
  28.         
  29.         #output {
  30.             margin-top: 20px;
  31.             padding: 10px;
  32.             background-color: #f9f9f9;
  33.             border: 1px solid #ddd;
  34.         }
  35.         
  36.         button {
  37.             margin: 5px;
  38.             padding: 8px 12px;
  39.         }
  40.     </style>
  41. </head>
  42. <body>
  43.     <div id="outer">外层元素
  44.         <div id="inner">内层元素</div>
  45.     </div>
  46.     <div>
  47.         <button id="stopPropagationBtn">使用stopPropagation</button>
  48.         <button id="stopImmediateBtn">使用stopImmediatePropagation</button>
  49.         <button id="resetBtn">重置</button>
  50.     </div>
  51.     <div id="output"></div>
  53.     <script>
  54.         const outer = document.getElementById('outer');
  55.         const inner = document.getElementById('inner');
  56.         const output = document.getElementById('output');
  57.         const stopPropagationBtn = document.getElementById('stopPropagationBtn');
  58.         const stopImmediateBtn = document.getElementById('stopImmediatePropagationBtn');
  59.         const resetBtn = document.getElementById('resetBtn');
  60.         
  61.         let stopPropagation = false;
  62.         let stopImmediatePropagation = false;
  63.         
  64.         function log(message) {
  65.             const p = document.createElement('p');
  66.             p.textContent = message;
  67.             output.appendChild(p);
  68.         }
  69.         
  70.         // 外层元素事件监听器
  71.         outer.addEventListener('click', function(event) {
  72.             log('外层元素点击事件触发');
  73.         });
  74.         
  75.         // 内层元素第一个事件监听器
  76.         inner.addEventListener('click', function(event) {
  77.             log('内层元素第一个点击事件触发');
  78.             
  79.             if (stopPropagation) {
  80.                 event.stopPropagation();
  81.                 log('事件传播已停止（stopPropagation）');
  82.             }
  83.             
  84.             if (stopImmediatePropagation) {
  85.                 event.stopImmediatePropagation();
  86.                 log('事件传播已立即停止（stopImmediatePropagation）');
  87.             }
  88.         });
  89.         
  90.         // 内层元素第二个事件监听器
  91.         inner.addEventListener('click', function(event) {
  92.             log('内层元素第二个点击事件触发');
  93.         });
  94.         
  95.         // 按钮事件监听器
  96.         stopPropagationBtn.addEventListener('click', function() {
  97.             stopPropagation = true;
  98.             stopImmediatePropagation = false;
  99.             output.innerHTML = '';
  100.             log('已设置使用stopPropagation');
  101.         });
  102.         
  103.         stopImmediateBtn.addEventListener('click', function() {
  104.             stopPropagation = false;
  105.             stopImmediatePropagation = true;
  106.             output.innerHTML = '';
  107.             log('已设置使用stopImmediatePropagation');
  108.         });
  109.         
  110.         resetBtn.addEventListener('click', function() {
  111.             stopPropagation = false;
  112.             stopImmediatePropagation = false;
  113.             output.innerHTML = '';
  114.             log('已重置');
  115.         });
  116.     </script>
  117. </body>
  118. </html>
复制代码

在这个示例中，我们可以通过按钮来测试stopPropagation和stopImmediatePropagation的效果。当使用stopPropagation时，事件不会传播到父元素，但同一元素上的其他事件处理函数仍会被调用。而当使用stopImmediatePropagation时，不仅事件不会传播，同一元素上的其他事件处理函数也不会被调用。

事件委托

什么是事件委托

事件委托是一种利用事件冒泡机制的技术，通过在父元素上设置事件监听器来管理其所有子元素的事件。这样做的好处是：

1. 减少内存使用：只需要一个事件监听器，而不是为每个子元素都添加一个
2. 动态元素支持：可以处理动态添加到DOM中的元素的事件
3. 简化代码：不需要为每个元素单独添加事件监听器

事件委托的基本实现
  2. <!DOCTYPE html>
  3. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7.     <title>事件委托基本实现</title>
  8.     <style>
  9.         #buttonContainer {
  10.             margin: 20px 0;
  11.         }
  12.         
  13.         button {
  14.             padding: 8px 12px;
  15.             margin: 5px;
  16.             cursor: pointer;
  17.         }
  18.         
  19.         #output {
  20.             padding: 10px;
  21.             background-color: #f9f9f9;
  22.             border: 1px solid #ddd;
  23.             min-height: 50px;
  24.         }
  25.         
  26.         #addButton {
  27.             background-color: #4CAF50;
  28.             color: white;
  29.             border: none;
  30.             padding: 10px 15px;
  31.             margin-top: 10px;
  32.         }
  33.     </style>
  34. </head>
  35. <body>
  36.     <h2>事件委托示例</h2>
  37.     <div id="buttonContainer">
  38.         <button class="action-btn" data-action="save">保存</button>
  39.         <button class="action-btn" data-action="delete">删除</button>
  40.         <button class="action-btn" data-action="edit">编辑</button>
  41.     </div>
  42.     <button id="addButton">添加新按钮</button>
  43.     <div id="output"></div>
  45.     <script>
  46.         const buttonContainer = document.getElementById('buttonContainer');
  47.         const addButton = document.getElementById('addButton');
  48.         const output = document.getElementById('output');
  49.         let buttonCount = 3;
  50.         
  51.         // 使用事件委托，在父元素上添加事件监听器
  52.         buttonContainer.addEventListener('click', function(event) {
  53.             // 检查点击的元素是否是我们感兴趣的按钮
  54.             if (event.target.classList.contains('action-btn')) {
  55.                 const action = event.target.getAttribute('data-action');
  56.                 output.textContent = `执行了 ${action} 操作`;
  57.             }
  58.         });
  59.         
  60.         // 添加新按钮的功能
  61.         addButton.addEventListener('click', function() {
  62.             buttonCount++;
  63.             const newButton = document.createElement('button');
  64.             newButton.className = 'action-btn';
  65.             newButton.setAttribute('data-action', `新操作${buttonCount}`);
  66.             newButton.textContent = `新操作${buttonCount}`;
  67.             buttonContainer.appendChild(newButton);
  68.             
  69.             output.textContent = `添加了新按钮：新操作${buttonCount}`;
  70.         });
  71.     </script>
  72. </body>
  73. </html>
复制代码

在这个示例中，我们在父元素buttonContainer上添加了一个事件监听器，通过检查event.target的类名和属性来确定点击的是哪个按钮。这样，即使动态添加新的按钮，也不需要为它们单独添加事件监听器。

事件委托的高级应用
  2. <!DOCTYPE html>
  3. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7.     <title>事件委托高级应用</title>
  8.     <style>
  9.         body {
  10.             font-family: Arial, sans-serif;
  11.             max-width: 800px;
  12.             margin: 0 auto;
  13.             padding: 20px;
  14.         }
  15.         
  16.         #todoList {
  17.             list-style: none;
  18.             padding: 0;
  19.         }
  20.         
  21.         .todo-item {
  22.             display: flex;
  23.             align-items: center;
  24.             padding: 10px;
  25.             border-bottom: 1px solid #eee;
  26.         }
  27.         
  28.         .todo-item.completed {
  29.             text-decoration: line-through;
  30.             color: #999;
  31.         }
  32.         
  33.         .todo-text {
  34.             flex-grow: 1;
  35.             margin: 0 10px;
  36.         }
  37.         
  38.         .todo-checkbox {
  39.             margin-right: 10px;
  40.         }
  41.         
  42.         .delete-btn {
  43.             background-color: #ff4444;
  44.             color: white;
  45.             border: none;
  46.             padding: 5px 10px;
  47.             cursor: pointer;
  48.             border-radius: 3px;
  49.         }
  50.         
  51.         .add-todo {
  52.             display: flex;
  53.             margin-top: 20px;
  54.         }
  55.         
  56.         .add-todo input {
  57.             flex-grow: 1;
  58.             padding: 8px;
  59.             border: 1px solid #ddd;
  60.             border-radius: 3px;
  61.         }
  62.         
  63.         .add-todo button {
  64.             background-color: #4CAF50;
  65.             color: white;
  66.             border: none;
  67.             padding: 8px 15px;
  68.             margin-left: 10px;
  69.             cursor: pointer;
  70.             border-radius: 3px;
  71.         }
  72.         
  73.         .filter-buttons {
  74.             margin: 20px 0;
  75.         }
  76.         
  77.         .filter-buttons button {
  78.             background-color: #f0f0f0;
  79.             border: 1px solid #ddd;
  80.             padding: 5px 10px;
  81.             margin-right: 5px;
  82.             cursor: pointer;
  83.         }
  84.         
  85.         .filter-buttons button.active {
  86.             background-color: #4CAF50;
  87.             color: white;
  88.         }
  89.     </style>
  90. </head>
  91. <body>
  92.     <h1>待办事项列表</h1>
  93.    
  94.     <div class="filter-buttons">
  95.         <button class="filter-btn active" data-filter="all">全部</button>
  96.         <button class="filter-btn" data-filter="active">未完成</button>
  97.         <button class="filter-btn" data-filter="completed">已完成</button>
  98.     </div>
  99.    
  100.     <ul id="todoList">
  101.         <li class="todo-item" data-id="1">
  102.             <input type="checkbox" class="todo-checkbox">
  103.             <span class="todo-text">学习JavaScript</span>
  104.             <button class="delete-btn">删除</button>
  105.         </li>
  106.         <li class="todo-item" data-id="2">
  107.             <input type="checkbox" class="todo-checkbox">
  108.             <span class="todo-text">学习HTML</span>
  109.             <button class="delete-btn">删除</button>
  110.         </li>
  111.         <li class="todo-item completed" data-id="3">
  112.             <input type="checkbox" class="todo-checkbox" checked>
  113.             <span class="todo-text">学习CSS</span>
  114.             <button class="delete-btn">删除</button>
  115.         </li>
  116.     </ul>
  117.    
  118.     <div class="add-todo">
  119.         <input type="text" id="newTodoInput" placeholder="添加新的待办事项">
  120.         <button id="addTodoBtn">添加</button>
  121.     </div>
  123.     <script>
  124.         const todoList = document.getElementById('todoList');
  125.         const newTodoInput = document.getElementById('newTodoInput');
  126.         const addTodoBtn = document.getElementById('addTodoBtn');
  127.         const filterButtons = document.querySelectorAll('.filter-btn');
  128.         let nextId = 4;
  129.         let currentFilter = 'all';
  130.         
  131.         // 使用事件委托处理待办事项列表的点击事件
  132.         todoList.addEventListener('click', function(event) {
  133.             const target = event.target;
  134.             const todoItem = target.closest('.todo-item');
  135.             
  136.             if (!todoItem) return;
  137.             
  138.             // 处理复选框点击
  139.             if (target.classList.contains('todo-checkbox')) {
  140.                 todoItem.classList.toggle('completed', target.checked);
  141.                 applyFilter();
  142.             }
  143.             
  144.             // 处理删除按钮点击
  145.             if (target.classList.contains('delete-btn')) {
  146.                 todoItem.remove();
  147.             }
  148.         });
  149.         
  150.         // 使用事件委托处理过滤按钮的点击事件
  151.         document.querySelector('.filter-buttons').addEventListener('click', function(event) {
  152.             if (event.target.classList.contains('filter-btn')) {
  153.                 // 更新活动按钮
  154.                 filterButtons.forEach(btn => btn.classList.remove('active'));
  155.                 event.target.classList.add('active');
  156.                
  157.                 // 更新当前过滤器并应用
  158.                 currentFilter = event.target.getAttribute('data-filter');
  159.                 applyFilter();
  160.             }
  161.         });
  162.         
  163.         // 添加新的待办事项
  164.         addTodoBtn.addEventListener('click', addNewTodo);
  165.         newTodoInput.addEventListener('keypress', function(event) {
  166.             if (event.key === 'Enter') {
  167.                 addNewTodo();
  168.             }
  169.         });
  170.         
  171.         function addNewTodo() {
  172.             const todoText = newTodoInput.value.trim();
  173.             if (!todoText) return;
  174.             
  175.             const newTodo = document.createElement('li');
  176.             newTodo.className = 'todo-item';
  177.             newTodo.setAttribute('data-id', nextId++);
  178.             newTodo.innerHTML = `
  179.                 <input type="checkbox" class="todo-checkbox">
  180.                 <span class="todo-text">${todoText}</span>
  181.                 <button class="delete-btn">删除</button>
  182.             `;
  183.             
  184.             todoList.appendChild(newTodo);
  185.             newTodoInput.value = '';
  186.             applyFilter();
  187.         }
  188.         
  189.         // 应用当前过滤器
  190.         function applyFilter() {
  191.             const todoItems = document.querySelectorAll('.todo-item');
  192.             
  193.             todoItems.forEach(item => {
  194.                 switch (currentFilter) {
  195.                     case 'all':
  196.                         item.style.display = 'flex';
  197.                         break;
  198.                     case 'active':
  199.                         item.style.display = item.classList.contains('completed') ? 'none' : 'flex';
  200.                         break;
  201.                     case 'completed':
  202.                         item.style.display = item.classList.contains('completed') ? 'flex' : 'none';
  203.                         break;
  204.                 }
  205.             });
  206.         }
  207.     </script>
  208. </body>
  209. </html>
复制代码

这个待办事项列表应用展示了事件委托的高级应用。我们在父元素todoList上添加了一个事件监听器，处理所有子元素的点击事件，包括复选框和删除按钮。同样，我们在过滤按钮的父元素上添加了事件监听器，处理所有过滤按钮的点击事件。这样，即使动态添加新的待办事项，也不需要为它们单独添加事件监听器。

最佳实践与性能优化

事件监听器的最佳实践

1. 使用事件委托：对于有多个子元素需要相同事件处理的情况，使用事件委托可以减少内存使用并简化代码。
2. 避免在循环中添加事件监听器：在循环中为多个元素添加事件监听器会导致性能问题，应该使用事件委托。
3. 及时移除不需要的事件监听器：当元素被移除或不再需要事件监听时，应该使用removeEventListener移除它们，避免内存泄漏。
4. 使用被动事件监听器提高滚动性能：对于wheel和touchstart等事件，可以使用passive: true选项来提高滚动性能。

使用事件委托：对于有多个子元素需要相同事件处理的情况，使用事件委托可以减少内存使用并简化代码。

避免在循环中添加事件监听器：在循环中为多个元素添加事件监听器会导致性能问题，应该使用事件委托。

及时移除不需要的事件监听器：当元素被移除或不再需要事件监听时，应该使用removeEventListener移除它们，避免内存泄漏。

使用被动事件监听器提高滚动性能：对于wheel和touchstart等事件，可以使用passive: true选项来提高滚动性能。
  2. // 使用被动事件监听器
  3. element.addEventListener('wheel', handler, { passive: true });
  4. element.addEventListener('touchstart', handler, { passive: true });
复制代码

1. 使用事件节流和防抖：对于频繁触发的事件（如resize、scroll），使用节流(throttle)和防抖(debounce)技术来限制事件处理函数的调用频率。

事件节流和防抖示例
  2. <!DOCTYPE html>
  3. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7.     <title>事件节流和防抖示例</title>
  8.     <style>
  9.         body {
  10.             font-family: Arial, sans-serif;
  11.             max-width: 800px;
  12.             margin: 0 auto;
  13.             padding: 20px;
  14.         }
  15.         
  16.         .box {
  17.             width: 100%;
  18.             height: 200px;
  19.             border: 1px solid #ccc;
  20.             margin: 20px 0;
  21.             overflow-y: auto;
  22.             padding: 10px;
  23.         }
  24.         
  25.         .content {
  26.             height: 1000px;
  27.             background: linear-gradient(to bottom, #f0f0f0, #ddd);
  28.         }
  29.         
  30.         .counter {
  31.             margin: 10px 0;
  32.             padding: 10px;
  33.             background-color: #f9f9f9;
  34.             border: 1px solid #ddd;
  35.         }
  36.         
  37.         button {
  38.             padding: 8px 12px;
  39.             margin: 5px;
  40.             cursor: pointer;
  41.         }
  42.         
  43.         .active {
  44.             background-color: #4CAF50;
  45.             color: white;
  46.         }
  47.     </style>
  48. </head>
  49. <body>
  50.     <h1>事件节流和防抖示例</h1>
  51.    
  52.     <div>
  53.         <button id="normalBtn" class="active">普通滚动事件</button>
  54.         <button id="throttleBtn">节流滚动事件</button>
  55.         <button id="debounceBtn">防抖滚动事件</button>
  56.     </div>
  57.    
  58.     <div class="counter">
  59.         普通事件触发次数: <span id="normalCount">0</span>
  60.     </div>
  61.    
  62.     <div class="counter">
  63.         节流事件触发次数: <span id="throttleCount">0</span>
  64.     </div>
  65.    
  66.     <div class="counter">
  67.         防抖事件触发次数: <span id="debounceCount">0</span>
  68.     </div>
  69.    
  70.     <div class="box" id="scrollBox">
  71.         <div class="content">滚动此区域测试事件节流和防抖效果</div>
  72.     </div>
  74.     <script>
  75.         const scrollBox = document.getElementById('scrollBox');
  76.         const normalCount = document.getElementById('normalCount');
  77.         const throttleCount = document.getElementById('throttleCount');
  78.         const debounceCount = document.getElementById('debounceCount');
  79.         const normalBtn = document.getElementById('normalBtn');
  80.         const throttleBtn = document.getElementById('throttleBtn');
  81.         const debounceBtn = document.getElementById('debounceBtn');
  82.         
  83.         let normalCounter = 0;
  84.         let throttleCounter = 0;
  85.         let debounceCounter = 0;
  86.         
  87.         // 节流函数
  88.         function throttle(func, delay) {
  89.             let lastCall = 0;
  90.             return function(...args) {
  91.                 const now = new Date().getTime();
  92.                 if (now - lastCall < delay) {
  93.                     return;
  94.                 }
  95.                 lastCall = now;
  96.                 return func.apply(this, args);
  97.             };
  98.         }
  99.         
  100.         // 防抖函数
  101.         function debounce(func, delay) {
  102.             let timeoutId;
  103.             return function(...args) {
  104.                 clearTimeout(timeoutId);
  105.                 timeoutId = setTimeout(() => {
  106.                     func.apply(this, args);
  107.                 }, delay);
  108.             };
  109.         }
  110.         
  111.         // 普通滚动事件处理函数
  112.         function handleNormalScroll() {
  113.             normalCounter++;
  114.             normalCount.textContent = normalCounter;
  115.         }
  116.         
  117.         // 节流滚动事件处理函数
  118.         function handleThrottleScroll() {
  119.             throttleCounter++;
  120.             throttleCount.textContent = throttleCounter;
  121.         }
  122.         
  123.         // 防抖滚动事件处理函数
  124.         function handleDebounceScroll() {
  125.             debounceCounter++;
  126.             debounceCount.textContent = debounceCounter;
  127.         }
  128.         
  129.         // 创建节流和防抖版本的事件处理函数
  130.         const throttledScrollHandler = throttle(handleThrottleScroll, 200);
  131.         const debouncedScrollHandler = debounce(handleDebounceScroll, 200);
  132.         
  133.         // 初始状态：只使用普通滚动事件
  134.         scrollBox.addEventListener('scroll', handleNormalScroll);
  135.         
  136.         // 按钮事件处理
  137.         normalBtn.addEventListener('click', function() {
  138.             // 移除所有事件监听器
  139.             scrollBox.removeEventListener('scroll', handleNormalScroll);
  140.             scrollBox.removeEventListener('scroll', throttledScrollHandler);
  141.             scrollBox.removeEventListener('scroll', debouncedScrollHandler);
  142.             
  143.             // 添加普通滚动事件监听器
  144.             scrollBox.addEventListener('scroll', handleNormalScroll);
  145.             
  146.             // 更新按钮状态
  147.             normalBtn.classList.add('active');
  148.             throttleBtn.classList.remove('active');
  149.             debounceBtn.classList.remove('active');
  150.             
  151.             // 重置计数器
  152.             normalCounter = 0;
  153.             throttleCounter = 0;
  154.             debounceCounter = 0;
  155.             normalCount.textContent = '0';
  156.             throttleCount.textContent = '0';
  157.             debounceCount.textContent = '0';
  158.         });
  159.         
  160.         throttleBtn.addEventListener('click', function() {
  161.             // 移除所有事件监听器
  162.             scrollBox.removeEventListener('scroll', handleNormalScroll);
  163.             scrollBox.removeEventListener('scroll', throttledScrollHandler);
  164.             scrollBox.removeEventListener('scroll', debouncedScrollHandler);
  165.             
  166.             // 添加节流滚动事件监听器
  167.             scrollBox.addEventListener('scroll', handleNormalScroll);
  168.             scrollBox.addEventListener('scroll', throttledScrollHandler);
  169.             
  170.             // 更新按钮状态
  171.             normalBtn.classList.remove('active');
  172.             throttleBtn.classList.add('active');
  173.             debounceBtn.classList.remove('active');
  174.             
  175.             // 重置计数器
  176.             normalCounter = 0;
  177.             throttleCounter = 0;
  178.             debounceCounter = 0;
  179.             normalCount.textContent = '0';
  180.             throttleCount.textContent = '0';
  181.             debounceCount.textContent = '0';
  182.         });
  183.         
  184.         debounceBtn.addEventListener('click', function() {
  185.             // 移除所有事件监听器
  186.             scrollBox.removeEventListener('scroll', handleNormalScroll);
  187.             scrollBox.removeEventListener('scroll', throttledScrollHandler);
  188.             scrollBox.removeEventListener('scroll', debouncedScrollHandler);
  189.             
  190.             // 添加防抖滚动事件监听器
  191.             scrollBox.addEventListener('scroll', handleNormalScroll);
  192.             scrollBox.addEventListener('scroll', debouncedScrollHandler);
  193.             
  194.             // 更新按钮状态
  195.             normalBtn.classList.remove('active');
  196.             throttleBtn.classList.add('active');
  197.             debounceBtn.classList.remove('active');
  198.             
  199.             // 重置计数器
  200.             normalCounter = 0;
  201.             throttleCounter = 0;
  202.             debounceCounter = 0;
  203.             normalCount.textContent = '0';
  204.             throttleCount.textContent = '0';
  205.             debounceCount.textContent = '0';
  206.         });
  207.     </script>
  208. </body>
  209. </html>
复制代码

在这个示例中，我们实现了事件节流和防抖的功能，并通过一个可滚动的区域来测试它们的效果。节流函数确保事件处理函数在一定时间内只执行一次，而防抖函数确保事件处理函数只在事件停止触发一段时间后执行。

实际应用案例

动态表格操作
  2. <!DOCTYPE html>
  3. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7.     <title>动态表格操作</title>
  8.     <style>
  9.         body {
  10.             font-family: Arial, sans-serif;
  11.             max-width: 1000px;
  12.             margin: 0 auto;
  13.             padding: 20px;
  14.         }
  15.         
  16.         table {
  17.             width: 100%;
  18.             border-collapse: collapse;
  19.             margin: 20px 0;
  20.         }
  21.         
  22.         th, td {
  23.             border: 1px solid #ddd;
  24.             padding: 8px;
  25.             text-align: left;
  26.         }
  27.         
  28.         th {
  29.             background-color: #f2f2f2;
  30.         }
  31.         
  32.         tr:hover {
  33.             background-color: #f5f5f5;
  34.         }
  35.         
  36.         .action-btn {
  37.             padding: 4px 8px;
  38.             margin: 0 2px;
  39.             cursor: pointer;
  40.             border: none;
  41.             border-radius: 3px;
  42.         }
  43.         
  44.         .edit-btn {
  45.             background-color: #4CAF50;
  46.             color: white;
  47.         }
  48.         
  49.         .delete-btn {
  50.             background-color: #f44336;
  51.             color: white;
  52.         }
  53.         
  54.         .save-btn {
  55.             background-color: #2196F3;
  56.             color: white;
  57.         }
  58.         
  59.         .cancel-btn {
  60.             background-color: #9e9e9e;
  61.             color: white;
  62.         }
  63.         
  64.         .add-form {
  65.             display: flex;
  66.             margin: 20px 0;
  67.             gap: 10px;
  68.         }
  69.         
  70.         .add-form input {
  71.             padding: 8px;
  72.             border: 1px solid #ddd;
  73.             border-radius: 3px;
  74.         }
  75.         
  76.         .add-form button {
  77.             padding: 8px 15px;
  78.             background-color: #4CAF50;
  79.             color: white;
  80.             border: none;
  81.             border-radius: 3px;
  82.             cursor: pointer;
  83.         }
  84.         
  85.         .notification {
  86.             padding: 10px;
  87.             margin: 10px 0;
  88.             border-radius: 3px;
  89.             display: none;
  90.         }
  91.         
  92.         .success {
  93.             background-color: #dff0d8;
  94.             color: #3c763d;
  95.             border: 1px solid #d6e9c6;
  96.         }
  97.         
  98.         .error {
  99.             background-color: #f2dede;
  100.             color: #a94442;
  101.             border: 1px solid #ebccd1;
  102.         }
  103.     </style>
  104. </head>
  105. <body>
  106.     <h1>员工信息管理</h1>
  107.    
  108.     <div class="notification" id="notification"></div>
  109.    
  110.     <div class="add-form">
  111.         <input type="text" id="nameInput" placeholder="姓名">
  112.         <input type="text" id="positionInput" placeholder="职位">
  113.         <input type="email" id="emailInput" placeholder="邮箱">
  114.         <button id="addBtn">添加员工</button>
  115.     </div>
  116.    
  117.     <table id="employeeTable">
  118.         <thead>
  119.             <tr>
  120.                 <th>ID</th>
  121.                 <th>姓名</th>
  122.                 <th>职位</th>
  123.                 <th>邮箱</th>
  124.                 <th>操作</th>
  125.             </tr>
  126.         </thead>
  127.         <tbody>
  128.             <tr data-id="1">
  129.                 <td>1</td>
  130.                 <td>张三</td>
  131.                 <td>前端开发</td>
  132.                 <td>zhangsan@example.com</td>
  133.                 <td>
  134.                     <button class="action-btn edit-btn">编辑</button>
  135.                     <button class="action-btn delete-btn">删除</button>
  136.                 </td>
  137.             </tr>
  138.             <tr data-id="2">
  139.                 <td>2</td>
  140.                 <td>李四</td>
  141.                 <td>后端开发</td>
  142.                 <td>lisi@example.com</td>
  143.                 <td>
  144.                     <button class="action-btn edit-btn">编辑</button>
  145.                     <button class="action-btn delete-btn">删除</button>
  146.                 </td>
  147.             </tr>
  148.             <tr data-id="3">
  149.                 <td>3</td>
  150.                 <td>王五</td>
  151.                 <td>产品经理</td>
  152.                 <td>wangwu@example.com</td>
  153.                 <td>
  154.                     <button class="action-btn edit-btn">编辑</button>
  155.                     <button class="action-btn delete-btn">删除</button>
  156.                 </td>
  157.             </tr>
  158.         </tbody>
  159.     </table>
  161.     <script>
  162.         const employeeTable = document.getElementById('employeeTable');
  163.         const nameInput = document.getElementById('nameInput');
  164.         const positionInput = document.getElementById('positionInput');
  165.         const emailInput = document.getElementById('emailInput');
  166.         const addBtn = document.getElementById('addBtn');
  167.         const notification = document.getElementById('notification');
  168.         let nextId = 4;
  169.         
  170.         // 显示通知
  171.         function showNotification(message, type) {
  172.             notification.textContent = message;
  173.             notification.className = `notification ${type}`;
  174.             notification.style.display = 'block';
  175.             
  176.             setTimeout(() => {
  177.                 notification.style.display = 'none';
  178.             }, 3000);
  179.         }
  180.         
  181.         // 使用事件委托处理表格中的点击事件
  182.         employeeTable.addEventListener('click', function(event) {
  183.             const target = event.target;
  184.             
  185.             // 处理编辑按钮点击
  186.             if (target.classList.contains('edit-btn')) {
  187.                 const row = target.closest('tr');
  188.                 const cells = row.querySelectorAll('td');
  189.                
  190.                 // 检查是否已经在编辑模式
  191.                 if (target.textContent === '保存') {
  192.                     // 保存编辑
  193.                     const nameCell = cells[1];
  194.                     const positionCell = cells[2];
  195.                     const emailCell = cells[3];
  196.                     
  197.                     const nameInput = nameCell.querySelector('input');
  198.                     const positionInput = positionCell.querySelector('input');
  199.                     const emailInput = emailCell.querySelector('input');
  200.                     
  201.                     // 验证输入
  202.                     if (!nameInput.value.trim() || !positionInput.value.trim() || !emailInput.value.trim()) {
  203.                         showNotification('所有字段都必须填写', 'error');
  204.                         return;
  205.                     }
  206.                     
  207.                     // 更新单元格内容
  208.                     nameCell.textContent = nameInput.value;
  209.                     positionCell.textContent = positionInput.value;
  210.                     emailCell.textContent = emailInput.value;
  211.                     
  212.                     // 恢复按钮
  213.                     target.textContent = '编辑';
  214.                     target.className = 'action-btn edit-btn';
  215.                     row.querySelector('.cancel-btn').style.display = 'none';
  216.                     
  217.                     showNotification('员工信息已更新', 'success');
  218.                 } else {
  219.                     // 进入编辑模式
  220.                     const name = cells[1].textContent;
  221.                     const position = cells[2].textContent;
  222.                     const email = cells[3].textContent;
  223.                     
  224.                     // 替换单元格内容为输入框
  225.                     cells[1].innerHTML = `<input type="text" value="${name}">`;
  226.                     cells[2].innerHTML = `<input type="text" value="${position}">`;
  227.                     cells[3].innerHTML = `<input type="email" value="${email}">`;
  228.                     
  229.                     // 更改按钮
  230.                     target.textContent = '保存';
  231.                     target.className = 'action-btn save-btn';
  232.                     
  233.                     // 添加取消按钮
  234.                     const cancelBtn = document.createElement('button');
  235.                     cancelBtn.textContent = '取消';
  236.                     cancelBtn.className = 'action-btn cancel-btn';
  237.                     cells[4].appendChild(cancelBtn);
  238.                 }
  239.             }
  240.             
  241.             // 处理删除按钮点击
  242.             if (target.classList.contains('delete-btn')) {
  243.                 const row = target.closest('tr');
  244.                 const name = row.cells[1].textContent;
  245.                
  246.                 if (confirm(`确定要删除员工 ${name} 吗？`)) {
  247.                     row.remove();
  248.                     showNotification(`员工 ${name} 已被删除`, 'success');
  249.                 }
  250.             }
  251.             
  252.             // 处理取消按钮点击
  253.             if (target.classList.contains('cancel-btn')) {
  254.                 location.reload(); // 简单起见，重新加载页面
  255.             }
  256.         });
  257.         
  258.         // 添加新员工
  259.         addBtn.addEventListener('click', function() {
  260.             const name = nameInput.value.trim();
  261.             const position = positionInput.value.trim();
  262.             const email = emailInput.value.trim();
  263.             
  264.             // 验证输入
  265.             if (!name || !position || !email) {
  266.                 showNotification('所有字段都必须填写', 'error');
  267.                 return;
  268.             }
  269.             
  270.             // 创建新行
  271.             const newRow = document.createElement('tr');
  272.             newRow.setAttribute('data-id', nextId);
  273.             newRow.innerHTML = `
  274.                 <td>${nextId}</td>
  275.                 <td>${name}</td>
  276.                 <td>${position}</td>
  277.                 <td>${email}</td>
  278.                 <td>
  279.                     <button class="action-btn edit-btn">编辑</button>
  280.                     <button class="action-btn delete-btn">删除</button>
  281.                 </td>
  282.             `;
  283.             
  284.             // 添加到表格
  285.             employeeTable.querySelector('tbody').appendChild(newRow);
  286.             
  287.             // 清空输入框
  288.             nameInput.value = '';
  289.             positionInput.value = '';
  290.             emailInput.value = '';
  291.             
  292.             // 更新ID
  293.             nextId++;
  294.             
  295.             showNotification(`员工 ${name} 已添加`, 'success');
  296.         });
  297.         
  298.         // 支持按Enter键添加
  299.         [nameInput, positionInput, emailInput].forEach(input => {
  300.             input.addEventListener('keypress', function(event) {
  301.                 if (event.key === 'Enter') {
  302.                     addBtn.click();
  303.                 }
  304.             });
  305.         });
  306.     </script>
  307. </body>
  308. </html>
复制代码

这个动态表格操作示例展示了事件委托在实际应用中的强大功能。我们在表格的父元素上添加了一个事件监听器，处理所有编辑、删除和取消按钮的点击事件。这样，即使动态添加新的行，也不需要为它们单独添加事件监听器。

拖放功能实现
  2. <!DOCTYPE html>
  3. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7.     <title>拖放功能实现</title>
  8.     <style>
  9.         body {
  10.             font-family: Arial, sans-serif;
  11.             max-width: 1000px;
  12.             margin: 0 auto;
  13.             padding: 20px;
  14.         }
  15.         
  16.         .container {
  17.             display: flex;
  18.             justify-content: space-between;
  19.             margin: 20px 0;
  20.         }
  21.         
  22.         .list {
  23.             width: 45%;
  24.             min-height: 300px;
  25.             border: 2px dashed #ccc;
  26.             border-radius: 5px;
  27.             padding: 10px;
  28.             background-color: #f9f9f9;
  29.         }
  30.         
  31.         .list-title {
  32.             text-align: center;
  33.             margin-bottom: 10px;
  34.             font-weight: bold;
  35.         }
  36.         
  37.         .item {
  38.             padding: 10px;
  39.             margin: 5px 0;
  40.             background-color: #fff;
  41.             border: 1px solid #ddd;
  42.             border-radius: 3px;
  43.             cursor: move;
  44.             transition: transform 0.2s;
  45.         }
  46.         
  47.         .item:hover {
  48.             transform: translateY(-2px);
  49.             box-shadow: 0 2px 5px rgba(0,0,0,0.1);
  50.         }
  51.         
  52.         .item.dragging {
  53.             opacity: 0.5;
  54.         }
  55.         
  56.         .list.drag-over {
  57.             background-color: #e0f7fa;
  58.             border-color: #00bcd4;
  59.         }
  60.         
  61.         .notification {
  62.             padding: 10px;
  63.             margin: 10px 0;
  64.             border-radius: 3px;
  65.             display: none;
  66.         }
  67.         
  68.         .success {
  69.             background-color: #dff0d8;
  70.             color: #3c763d;
  71.             border: 1px solid #d6e9c6;
  72.         }
  73.         
  74.         .add-item {
  75.             display: flex;
  76.             margin: 20px 0;
  77.             gap: 10px;
  78.         }
  79.         
  80.         .add-item input {
  81.             flex-grow: 1;
  82.             padding: 8px;
  83.             border: 1px solid #ddd;
  84.             border-radius: 3px;
  85.         }
  86.         
  87.         .add-item button {
  88.             padding: 8px 15px;
  89.             background-color: #4CAF50;
  90.             color: white;
  91.             border: none;
  92.             border-radius: 3px;
  93.             cursor: pointer;
  94.         }
  95.     </style>
  96. </head>
  97. <body>
  98.     <h1>任务拖放管理</h1>
  99.    
  100.     <div class="notification" id="notification"></div>
  101.    
  102.     <div class="add-item">
  103.         <input type="text" id="newItemInput" placeholder="输入新任务">
  104.         <button id="addItemBtn">添加任务</button>
  105.     </div>
  106.    
  107.     <div class="container">
  108.         <div class="list" id="todoList">
  109.             <div class="list-title">待办事项</div>
  110.             <div class="item" draggable="true">完成项目报告</div>
  111.             <div class="item" draggable="true">准备会议材料</div>
  112.             <div class="item" draggable="true">回复客户邮件</div>
  113.         </div>
  114.         
  115.         <div class="list" id="doneList">
  116.             <div class="list-title">已完成</div>
  117.             <div class="item" draggable="true">更新网站内容</div>
  118.             <div class="item" draggable="true">修复登录问题</div>
  119.         </div>
  120.     </div>
  122.     <script>
  123.         const todoList = document.getElementById('todoList');
  124.         const doneList = document.getElementById('doneList');
  125.         const newItemInput = document.getElementById('newItemInput');
  126.         const addItemBtn = document.getElementById('addItemBtn');
  127.         const notification = document.getElementById('notification');
  128.         
  129.         // 显示通知
  130.         function showNotification(message) {
  131.             notification.textContent = message;
  132.             notification.className = 'notification success';
  133.             notification.style.display = 'block';
  134.             
  135.             setTimeout(() => {
  136.                 notification.style.display = 'none';
  137.             }, 3000);
  138.         }
  139.         
  140.         // 使用事件委托处理拖放事件
  141.         document.addEventListener('dragstart', function(event) {
  142.             if (event.target.classList.contains('item')) {
  143.                 event.target.classList.add('dragging');
  144.                 event.dataTransfer.effectAllowed = 'move';
  145.                 event.dataTransfer.setData('text/html', event.target.innerHTML);
  146.             }
  147.         });
  148.         
  149.         document.addEventListener('dragend', function(event) {
  150.             if (event.target.classList.contains('item')) {
  151.                 event.target.classList.remove('dragging');
  152.             }
  153.         });
  154.         
  155.         document.addEventListener('dragover', function(event) {
  156.             if (event.target.classList.contains('list')) {
  157.                 event.preventDefault();
  158.                 event.dataTransfer.dropEffect = 'move';
  159.             }
  160.         });
  161.         
  162.         document.addEventListener('dragenter', function(event) {
  163.             if (event.target.classList.contains('list')) {
  164.                 event.target.classList.add('drag-over');
  165.             }
  166.         });
  167.         
  168.         document.addEventListener('dragleave', function(event) {
  169.             if (event.target.classList.contains('list')) {
  170.                 event.target.classList.remove('drag-over');
  171.             }
  172.         });
  173.         
  174.         document.addEventListener('drop', function(event) {
  175.             if (event.target.classList.contains('list')) {
  176.                 event.preventDefault();
  177.                 event.target.classList.remove('drag-over');
  178.                
  179.                 const draggingItem = document.querySelector('.dragging');
  180.                 if (draggingItem) {
  181.                     const listTitle = event.target.querySelector('.list-title').textContent;
  182.                     const itemText = draggingItem.textContent;
  183.                     
  184.                     // 移动元素
  185.                     event.target.appendChild(draggingItem);
  186.                     
  187.                     // 显示通知
  188.                     showNotification(`任务"${itemText}"已移动到"${listTitle}"`);
  189.                 }
  190.             }
  191.         });
  192.         
  193.         // 添加新任务
  194.         addItemBtn.addEventListener('click', function() {
  195.             const itemText = newItemInput.value.trim();
  196.             if (!itemText) return;
  197.             
  198.             const newItem = document.createElement('div');
  199.             newItem.className = 'item';
  200.             newItem.draggable = true;
  201.             newItem.textContent = itemText;
  202.             
  203.             todoList.appendChild(newItem);
  204.             newItemInput.value = '';
  205.             
  206.             showNotification(`新任务"${itemText}"已添加`);
  207.         });
  208.         
  209.         // 支持按Enter键添加
  210.         newItemInput.addEventListener('keypress', function(event) {
  211.             if (event.key === 'Enter') {
  212.                 addItemBtn.click();
  213.             }
  214.         });
  215.     </script>
  216. </body>
  217. </html>
复制代码

这个拖放功能示例展示了如何使用HTML5的拖放API结合事件委托来实现一个任务管理界面。我们在document级别添加了拖放相关的事件监听器，通过检查event.target来确定事件源，从而实现了拖放功能。

总结

本文全面解析了HTML DOM事件监听的添加技巧，从基础的addEventListener方法到高级的事件委托技术。我们学习了：

1. addEventListener的基本用法：如何添加事件监听器，以及不同类型的事件处理函数。
2. 事件对象的详细解析：事件对象的属性和方法，以及如何利用它们获取事件相关信息。
3. 事件移除技术：如何使用removeEventListener移除不再需要的事件监听器。
4. 事件冒泡与捕获：理解事件流的三个阶段，以及如何控制事件的传播。
5. 事件委托技术：利用事件冒泡机制在父元素上处理子元素的事件，提高性能并简化代码。
6. 最佳实践与性能优化：包括事件节流、防抖等技术，以及如何优化事件处理性能。
7. 实际应用案例：通过动态表格操作和拖放功能等实例，展示了事件监听技术在实际开发中的应用。

掌握这些技术，可以帮助开发者创建出响应迅速、交互流畅的网页应用，提升用户体验。在实际开发中，应根据具体需求选择合适的事件处理方式，并注意性能优化，避免常见的问题。

随着Web技术的不断发展，事件处理也在不断演进。作为开发者，我们需要持续学习和实践，掌握最新的事件处理技术，以应对日益复杂的交互需求。
浏览器
「七転び八起き（ななころびやおき）」
回复

使用道具 举报

返回列表 发新帖
您需要登录后才可以回帖 登录 | 立即注册
高级模式
B Color Image Link Quote Code Smilies

本版积分规则