简体中文 繁體中文 English 日本語 Deutsch 한국 사람 بالعربية TÜRKÇE português คนไทย Français

开启辅助访问 切换到宽版

站内搜索

搜索

活动公告

通知：是的！我们正在计划一个大动作！
11-02 12:46
通知：Telegram 推送频道https://t.me/+2tB3a7aKXlw2YjA1 及时接收第一手论坛帖子信息～
10-23 09:32
通知：本站资源由网友上传分享，如有违规等问题请到版务模块进行投诉，将及时处理！
10-23 09:31
通知：加入QQ社群吧 https://qm.qq.com/q/QZibQd1hiq
10-23 09:28
通知：签到时间调整为每日4:00（东八区）
10-23 09:26
>社区 > 科技 > 经验交流 >帖子
本版发帖返回

JavaScript修改HTML DOM实战教程掌握动态网页开发的核心技能通过实际案例学习如何操作元素处理事件和更新页面内容

威震华夏关云长

3万

主题

317

科技点

3万

积分

大区版主

木柜子打湿

积分
31893

财Doro三倍冰淇淋无人之境【一阶】立华奏小樱（小丑装）⑨的冰沙以外的星空【二阶】
发表于 2025-10-4 09:00:00 | 显示全部楼层 |阅读模式

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

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

x
引言

在现代Web开发中，JavaScript操作DOM（文档对象模型）是创建动态、交互式网页的核心技能。DOM是一个编程接口，允许JavaScript访问和修改HTML文档的内容、结构和样式。通过掌握DOM操作，开发者可以创建响应式用户界面、处理用户交互、动态更新页面内容，从而提升用户体验。本教程将通过实际案例，系统地介绍如何使用JavaScript操作DOM元素、处理事件和更新页面内容。

DOM基础

什么是DOM

DOM（Document Object Model）是HTML和XML文档的编程接口。它将文档表示为一个树状结构，其中每个节点都是文档中的一个对象（如元素、属性、文本等）。JavaScript可以通过DOM API访问和操作这些对象。
  2. <!DOCTYPE html>
  3. <html>
  4. <head>
  5.     <title>DOM示例</title>
  6. </head>
  7. <body>
  8.     <h1>欢迎学习DOM</h1>
  9.     <p>这是一个段落。</p>
  10. </body>
  11. </html>
复制代码

在上面的HTML文档中，DOM树结构如下：
  2. Document
  3. └── html
  4.      ├── head
  5.      │   └── title
  6.      │       └── "DOM示例"
  7.      └── body
  8.          ├── h1
  9.          │   └── "欢迎学习DOM"
  10.          └── p
  11.              └── "这是一个段落。"
复制代码

DOM的重要性

DOM操作的重要性体现在：

1. 动态内容更新：无需刷新页面即可更新内容
2. 用户交互响应：实时响应用户的操作
3. 创建丰富的用户体验：实现动画、拖放等复杂交互
4. 数据驱动的界面：根据数据动态渲染界面

选择DOM元素

在操作DOM之前，首先需要选择要操作的元素。JavaScript提供了多种选择元素的方法。

getElementById

通过元素的ID选择单个元素。
  2. <div id="myDiv">这是一个div元素</div>
  4. <script>
  5.     // 通过ID选择元素
  6.     const myDiv = document.getElementById('myDiv');
  7.     console.log(myDiv.textContent); // 输出: 这是一个div元素
  8. </script>
复制代码

getElementsByClassName

通过类名选择多个元素，返回一个HTMLCollection。
  2. <div class="box">盒子1</div>
  3. <div class="box">盒子2</div>
  4. <div class="box">盒子3</div>
  6. <script>
  7.     // 通过类名选择元素
  8.     const boxes = document.getElementsByClassName('box');
  9.     console.log(boxes.length); // 输出: 3
  10.    
  11.     // 遍历所有盒子
  12.     for (let i = 0; i < boxes.length; i++) {
  13.         console.log(boxes[i].textContent);
  14.     }
  15. </script>
复制代码

getElementsByTagName

通过标签名选择多个元素，返回一个HTMLCollection。
  2. <p>段落1</p>
  3. <p>段落2</p>
  4. <p>段落3</p>
  6. <script>
  7.     // 通过标签名选择元素
  8.     const paragraphs = document.getElementsByTagName('p');
  9.     console.log(paragraphs.length); // 输出: 3
  10. </script>
复制代码

querySelector和querySelectorAll

使用CSS选择器语法选择元素。querySelector返回第一个匹配的元素，querySelectorAll返回所有匹配的元素（NodeList）。
  2. <div id="container">
  3.     <p class="text">第一段</p>
  4.     <p class="text">第二段</p>
  5.     <div class="text">这是一个div</div>
  6. </div>
  8. <script>
  9.     // 使用querySelector选择第一个匹配的元素
  10.     const firstText = document.querySelector('#container .text');
  11.     console.log(firstText.textContent); // 输出: 第一段
  12.    
  13.     // 使用querySelectorAll选择所有匹配的元素
  14.     const allTexts = document.querySelectorAll('#container .text');
  15.     console.log(allTexts.length); // 输出: 3
  16.    
  17.     // 遍历所有元素
  18.     allTexts.forEach(element => {
  19.         console.log(element.textContent);
  20.     });
  21. </script>
复制代码

修改元素内容

修改文本内容

使用textContent或innerText属性修改元素的文本内容。
  2. <div id="textElement">原始文本</div>
  3. <button id="changeTextBtn">修改文本</button>
  5. <script>
  6.     const textElement = document.getElementById('textElement');
  7.     const changeTextBtn = document.getElementById('changeTextBtn');
  8.    
  9.     changeTextBtn.addEventListener('click', function() {
  10.         // 使用textContent修改文本
  11.         textElement.textContent = '文本已被修改';
  12.         
  13.         // 3秒后再次修改
  14.         setTimeout(() => {
  15.             // 使用innerText修改文本（与textContent类似，但会考虑CSS样式）
  16.             textElement.innerText = '再次修改的文本';
  17.         }, 3000);
  18.     });
  19. </script>
复制代码

修改HTML内容

使用innerHTML属性修改元素的HTML内容。
  2. <div id="htmlElement">
  3.     <p>原始HTML内容</p>
  4. </div>
  5. <button id="changeHtmlBtn">修改HTML</button>
  7. <script>
  8.     const htmlElement = document.getElementById('htmlElement');
  9.     const changeHtmlBtn = document.getElementById('changeHtmlBtn');
  10.    
  11.     changeHtmlBtn.addEventListener('click', function() {
  12.         // 使用innerHTML修改HTML内容
  13.         htmlElement.innerHTML = `
  14.             <ul>
  15.                 <li>列表项1</li>
  16.                 <li>列表项2</li>
  17.                 <li>列表项3</li>
  18.             </ul>
  19.         `;
  20.     });
  21. </script>
复制代码

注意：使用innerHTML存在安全风险，如果内容来自用户输入，可能导致XSS攻击。对于不受信任的内容，应使用textContent或其他安全方法。

修改元素属性

标准属性

可以直接通过点表示法或setAttribute方法修改元素的标准属性。
  2. <img id="myImage" src="image1.jpg" alt="图片1" width="200">
  3. <button id="changeAttrBtn">修改属性</button>
  5. <script>
  6.     const myImage = document.getElementById('myImage');
  7.     const changeAttrBtn = document.getElementById('changeAttrBtn');
  8.    
  9.     changeAttrBtn.addEventListener('click', function() {
  10.         // 使用点表示法修改属性
  11.         myImage.src = 'image2.jpg';
  12.         myImage.alt = '图片2';
  13.         
  14.         // 使用setAttribute方法修改属性
  15.         myImage.setAttribute('width', '300');
  16.     });
  17. </script>
复制代码

自定义属性（data-*）

HTML5允许使用data-*属性存储自定义数据。
  2. <div id="dataElement" data-user-id="123" data-role="admin">用户信息</div>
  3. <button id="showDataBtn">显示数据</button>
  4. <button id="changeDataBtn">修改数据</button>
  6. <script>
  7.     const dataElement = document.getElementById('dataElement');
  8.     const showDataBtn = document.getElementById('showDataBtn');
  9.     const changeDataBtn = document.getElementById('changeDataBtn');
  10.    
  11.     showDataBtn.addEventListener('click', function() {
  12.         // 使用dataset属性访问data-*属性
  13.         const userId = dataElement.dataset.userId;
  14.         const role = dataElement.dataset.role;
  15.         
  16.         alert(`用户ID: ${userId}, 角色: ${role}`);
  17.     });
  18.    
  19.     changeDataBtn.addEventListener('click', function() {
  20.         // 修改data-*属性
  21.         dataElement.dataset.userId = '456';
  22.         dataElement.dataset.role = 'user';
  23.         
  24.         alert('数据已修改');
  25.     });
  26. </script>
复制代码

修改元素样式

直接修改style属性

可以通过元素的style对象直接修改CSS样式。
  2. <div id="styleElement" style="width: 100px; height: 100px; background-color: blue;"></div>
  3. <button id="changeStyleBtn">修改样式</button>
  5. <script>
  6.     const styleElement = document.getElementById('styleElement');
  7.     const changeStyleBtn = document.getElementById('changeStyleBtn');
  8.    
  9.     changeStyleBtn.addEventListener('click', function() {
  10.         // 直接修改style属性
  11.         styleElement.style.backgroundColor = 'red';
  12.         styleElement.style.width = '200px';
  13.         styleElement.style.height = '200px';
  14.         styleElement.style.borderRadius = '50%';
  15.     });
  16. </script>
复制代码

注意：CSS属性名在JavaScript中通常使用驼峰命名法，例如backgroundColor代替background-color。

通过classList修改类名

使用classList属性添加、删除、切换或检查元素的类名。
  2. <style>
  3.     .box {
  4.         width: 100px;
  5.         height: 100px;
  6.         background-color: blue;
  7.         transition: all 0.3s ease;
  8.     }
  9.    
  10.     .highlight {
  11.         background-color: yellow;
  12.         border: 2px solid red;
  13.     }
  14.    
  15.     .rounded {
  16.         border-radius: 50%;
  17.     }
  18. </style>
  20. <div id="classElement" class="box"></div>
  21. <button id="addClassBtn">添加高亮</button>
  22. <button id="toggleClassBtn">切换圆角</button>
  23. <button id="removeClassBtn">移除高亮</button>
  25. <script>
  26.     const classElement = document.getElementById('classElement');
  27.     const addClassBtn = document.getElementById('addClassBtn');
  28.     const toggleClassBtn = document.getElementById('toggleClassBtn');
  29.     const removeClassBtn = document.getElementById('removeClassBtn');
  30.    
  31.     addClassBtn.addEventListener('click', function() {
  32.         // 添加类名
  33.         classElement.classList.add('highlight');
  34.     });
  35.    
  36.     toggleClassBtn.addEventListener('click', function() {
  37.         // 切换类名（如果存在则移除，不存在则添加）
  38.         classElement.classList.toggle('rounded');
  39.     });
  40.    
  41.     removeClassBtn.addEventListener('click', function() {
  42.         // 移除类名
  43.         classElement.classList.remove('highlight');
  44.     });
  45. </script>
复制代码

创建和删除元素

创建新元素

使用document.createElement方法创建新元素，然后使用appendChild或insertBefore将其添加到DOM中。
  2. <div id="container">
  3.     <p>原始段落</p>
  4. </div>
  5. <button id="addElementBtn">添加元素</button>
  7. <script>
  8.     const container = document.getElementById('container');
  9.     const addElementBtn = document.getElementById('addElementBtn');
  10.    
  11.     addElementBtn.addEventListener('click', function() {
  12.         // 创建新元素
  13.         const newParagraph = document.createElement('p');
  14.         
  15.         // 设置元素内容
  16.         newParagraph.textContent = '这是新添加的段落';
  17.         
  18.         // 添加样式
  19.         newParagraph.style.color = 'red';
  20.         newParagraph.style.fontWeight = 'bold';
  21.         
  22.         // 将新元素添加到容器中
  23.         container.appendChild(newParagraph);
  24.     });
  25. </script>
复制代码

删除元素

使用removeChild方法或remove方法删除元素。
  2. <div id="elementsContainer">
  3.     <div class="item">项目1 <button class="deleteBtn">删除</button></div>
  4.     <div class="item">项目2 <button class="deleteBtn">删除</button></div>
  5.     <div class="item">项目3 <button class="deleteBtn">删除</button></div>
  6. </div>
  8. <script>
  9.     const elementsContainer = document.getElementById('elementsContainer');
  10.    
  11.     // 使用事件委托处理删除按钮的点击事件
  12.     elementsContainer.addEventListener('click', function(event) {
  13.         // 检查点击的是否是删除按钮
  14.         if (event.target.classList.contains('deleteBtn')) {
  15.             // 获取要删除的项目
  16.             const itemToDelete = event.target.parentElement;
  17.             
  18.             // 从父元素中删除子元素
  19.             elementsContainer.removeChild(itemToDelete);
  20.             
  21.             // 或者直接使用remove方法
  22.             // itemToDelete.remove();
  23.         }
  24.     });
  25. </script>
复制代码

克隆元素

使用cloneNode方法克隆元素，参数true表示深度克隆（包括所有子元素）。
  2. <div id="original">
  3.     <h2>原始元素</h2>
  4.     <p>这是一个段落。</p>
  5. </div>
  6. <button id="cloneBtn">克隆元素</button>
  7. <div id="clonesContainer"></div>
  9. <script>
  10.     const original = document.getElementById('original');
  11.     const cloneBtn = document.getElementById('cloneBtn');
  12.     const clonesContainer = document.getElementById('clonesContainer');
  13.    
  14.     cloneBtn.addEventListener('click', function() {
  15.         // 深度克隆原始元素
  16.         const clonedElement = original.cloneNode(true);
  17.         
  18.         // 修改克隆元素的ID以避免重复
  19.         clonedElement.id = 'cloned-' + Date.now();
  20.         
  21.         // 将克隆元素添加到容器中
  22.         clonesContainer.appendChild(clonedElement);
  23.     });
  24. </script>
复制代码

事件处理

事件监听器

使用addEventListener方法为元素添加事件监听器。
  2. <button id="clickBtn">点击我</button>
  3. <div id="output"></div>
  5. <script>
  6.     const clickBtn = document.getElementById('clickBtn');
  7.     const output = document.getElementById('output');
  8.    
  9.     // 添加点击事件监听器
  10.     clickBtn.addEventListener('click', function() {
  11.         output.textContent = '按钮被点击了！';
  12.         output.style.color = 'green';
  13.     });
  14.    
  15.     // 添加鼠标悬停事件监听器
  16.     clickBtn.addEventListener('mouseover', function() {
  17.         this.style.backgroundColor = 'lightblue';
  18.     });
  19.    
  20.     // 添加鼠标离开事件监听器
  21.     clickBtn.addEventListener('mouseout', function() {
  22.         this.style.backgroundColor = '';
  23.     });
  24. </script>
复制代码

事件对象

事件处理函数接收一个事件对象，包含关于事件的详细信息。
  2. <div id="mouseArea" style="width: 300px; height: 200px; background-color: #f0f0f0; padding: 10px;">
  3.     在此区域移动鼠标
  4. </div>
  5. <div id="mouseInfo"></div>
  7. <script>
  8.     const mouseArea = document.getElementById('mouseArea');
  9.     const mouseInfo = document.getElementById('mouseInfo');
  10.    
  11.     mouseArea.addEventListener('mousemove', function(event) {
  12.         // 获取鼠标位置
  13.         const x = event.clientX;
  14.         const y = event.clientY;
  15.         
  16.         // 显示鼠标位置信息
  17.         mouseInfo.innerHTML = `
  18.             <p>鼠标位置: X=${x}, Y=${y}</p>
  19.             <p>相对于元素: X=${event.offsetX}, Y=${event.offsetY}</p>
  20.         `;
  21.     });
  22. </script>
复制代码

事件冒泡和捕获

事件在DOM中的传播分为三个阶段：捕获阶段、目标阶段和冒泡阶段。
  2. <style>
  3.     .outer {
  4.         width: 300px;
  5.         height: 300px;
  6.         background-color: #f0f0f0;
  7.         padding: 20px;
  8.     }
  9.    
  10.     .middle {
  11.         width: 200px;
  12.         height: 200px;
  13.         background-color: #d0d0d0;
  14.         padding: 20px;
  15.     }
  16.    
  17.     .inner {
  18.         width: 100px;
  19.         height: 100px;
  20.         background-color: #b0b0b0;
  21.         padding: 20px;
  22.     }
  23. </style>
  25. <div id="outer" class="outer">
  26.     外层元素
  27.     <div id="middle" class="middle">
  28.         中层元素
  29.         <div id="inner" class="inner">
  30.             内层元素
  31.         </div>
  32.     </div>
  33. </div>
  35. <div id="eventLog"></div>
  37. <script>
  38.     const outer = document.getElementById('outer');
  39.     const middle = document.getElementById('middle');
  40.     const inner = document.getElementById('inner');
  41.     const eventLog = document.getElementById('eventLog');
  42.    
  43.     // 添加点击事件监听器（冒泡阶段）
  44.     outer.addEventListener('click', function(event) {
  45.         logEvent('外层元素 - 冒泡阶段');
  46.     });
  47.    
  48.     middle.addEventListener('click', function(event) {
  49.         logEvent('中层元素 - 冒泡阶段');
  50.     });
  51.    
  52.     inner.addEventListener('click', function(event) {
  53.         logEvent('内层元素 - 冒泡阶段');
  54.     });
  55.    
  56.     // 添加点击事件监听器（捕获阶段）
  57.     outer.addEventListener('click', function(event) {
  58.         logEvent('外层元素 - 捕获阶段');
  59.     }, true);
  60.    
  61.     middle.addEventListener('click', function(event) {
  62.         logEvent('中层元素 - 捕获阶段');
  63.     }, true);
  64.    
  65.     inner.addEventListener('click', function(event) {
  66.         logEvent('内层元素 - 捕获阶段');
  67.     }, true);
  68.    
  69.     function logEvent(message) {
  70.         const p = document.createElement('p');
  71.         p.textContent = message;
  72.         eventLog.appendChild(p);
  73.     }
  74. </script>
复制代码

事件委托

利用事件冒泡机制，在父元素上处理子元素的事件。
  2. <ul id="itemList">
  3.     <li data-id="1">项目1</li>
  4.     <li data-id="2">项目2</li>
  5.     <li data-id="3">项目3</li>
  6. </ul>
  7. <button id="addItemBtn">添加项目</button>
  8. <div id="selectedItem"></div>
  10. <script>
  11.     const itemList = document.getElementById('itemList');
  12.     const addItemBtn = document.getElementById('addItemBtn');
  13.     const selectedItem = document.getElementById('selectedItem');
  14.     let itemCount = 3;
  15.    
  16.     // 使用事件委托处理列表项的点击事件
  17.     itemList.addEventListener('click', function(event) {
  18.         // 检查点击的是否是列表项
  19.         if (event.target.tagName === 'LI') {
  20.             // 获取项目ID
  21.             const itemId = event.target.dataset.id;
  22.             
  23.             // 显示选中的项目
  24.             selectedItem.textContent = `选中的项目ID: ${itemId}, 内容: ${event.target.textContent}`;
  25.             
  26.             // 高亮选中的项目
  27.             // 移除所有项目的高亮
  28.             document.querySelectorAll('#itemList li').forEach(li => {
  29.                 li.style.backgroundColor = '';
  30.             });
  31.             
  32.             // 高亮当前项目
  33.             event.target.style.backgroundColor = 'lightblue';
  34.         }
  35.     });
  36.    
  37.     // 添加新项目
  38.     addItemBtn.addEventListener('click', function() {
  39.         itemCount++;
  40.         const newItem = document.createElement('li');
  41.         newItem.dataset.id = itemCount;
  42.         newItem.textContent = `项目${itemCount}`;
  43.         itemList.appendChild(newItem);
  44.     });
  45. </script>
复制代码

实战案例

动态待办事项列表

创建一个可以添加、删除和标记完成状态的待办事项列表。
  2. <!DOCTYPE html>
  3. <html lang="zh-CN">
  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: 600px;
  12.             margin: 0 auto;
  13.             padding: 20px;
  14.         }
  15.         
  16.         h1 {
  17.             text-align: center;
  18.             color: #333;
  19.         }
  20.         
  21.         .input-container {
  22.             display: flex;
  23.             margin-bottom: 20px;
  24.         }
  25.         
  26.         #todoInput {
  27.             flex: 1;
  28.             padding: 10px;
  29.             border: 1px solid #ddd;
  30.             border-radius: 4px;
  31.             font-size: 16px;
  32.         }
  33.         
  34.         #addBtn {
  35.             padding: 10px 15px;
  36.             background-color: #4CAF50;
  37.             color: white;
  38.             border: none;
  39.             border-radius: 4px;
  40.             margin-left: 10px;
  41.             cursor: pointer;
  42.             font-size: 16px;
  43.         }
  44.         
  45.         #addBtn:hover {
  46.             background-color: #45a049;
  47.         }
  48.         
  49.         #todoList {
  50.             list-style: none;
  51.             padding: 0;
  52.         }
  53.         
  54.         .todo-item {
  55.             display: flex;
  56.             align-items: center;
  57.             padding: 12px;
  58.             border-bottom: 1px solid #eee;
  59.         }
  60.         
  61.         .todo-item:last-child {
  62.             border-bottom: none;
  63.         }
  64.         
  65.         .todo-text {
  66.             flex: 1;
  67.             margin-left: 10px;
  68.         }
  69.         
  70.         .completed {
  71.             text-decoration: line-through;
  72.             color: #888;
  73.         }
  74.         
  75.         .delete-btn {
  76.             background-color: #f44336;
  77.             color: white;
  78.             border: none;
  79.             border-radius: 4px;
  80.             padding: 5px 10px;
  81.             cursor: pointer;
  82.         }
  83.         
  84.         .delete-btn:hover {
  85.             background-color: #d32f2f;
  86.         }
  87.         
  88.         .empty-state {
  89.             text-align: center;
  90.             color: #888;
  91.             padding: 20px;
  92.         }
  93.     </style>
  94. </head>
  95. <body>
  96.     <h1>待办事项列表</h1>
  97.    
  98.     <div class="input-container">
  99.         <input type="text" id="todoInput" placeholder="添加新的待办事项...">
  100.         <button id="addBtn">添加</button>
  101.     </div>
  102.    
  103.     <ul id="todoList">
  104.         <li class="empty-state">暂无待办事项，请添加新的项目</li>
  105.     </ul>
  107.     <script>
  108.         // 获取DOM元素
  109.         const todoInput = document.getElementById('todoInput');
  110.         const addBtn = document.getElementById('addBtn');
  111.         const todoList = document.getElementById('todoList');
  112.         
  113.         // 初始化待办事项数组
  114.         let todos = [];
  115.         
  116.         // 添加待办事项
  117.         function addTodo() {
  118.             const todoText = todoInput.value.trim();
  119.             
  120.             if (todoText === '') {
  121.                 alert('请输入待办事项内容');
  122.                 return;
  123.             }
  124.             
  125.             // 创建新的待办事项对象
  126.             const newTodo = {
  127.                 id: Date.now(),
  128.                 text: todoText,
  129.                 completed: false
  130.             };
  131.             
  132.             // 添加到数组
  133.             todos.push(newTodo);
  134.             
  135.             // 清空输入框
  136.             todoInput.value = '';
  137.             
  138.             // 渲染列表
  139.             renderTodos();
  140.         }
  141.         
  142.         // 删除待办事项
  143.         function deleteTodo(id) {
  144.             // 从数组中过滤掉要删除的项目
  145.             todos = todos.filter(todo => todo.id !== id);
  146.             
  147.             // 渲染列表
  148.             renderTodos();
  149.         }
  150.         
  151.         // 切换待办事项完成状态
  152.         function toggleTodo(id) {
  153.             // 查找并更新待办事项
  154.             todos = todos.map(todo => {
  155.                 if (todo.id === id) {
  156.                     return { ...todo, completed: !todo.completed };
  157.                 }
  158.                 return todo;
  159.             });
  160.             
  161.             // 渲染列表
  162.             renderTodos();
  163.         }
  164.         
  165.         // 渲染待办事项列表
  166.         function renderTodos() {
  167.             // 清空列表
  168.             todoList.innerHTML = '';
  169.             
  170.             // 检查是否有待办事项
  171.             if (todos.length === 0) {
  172.                 const emptyState = document.createElement('li');
  173.                 emptyState.className = 'empty-state';
  174.                 emptyState.textContent = '暂无待办事项，请添加新的项目';
  175.                 todoList.appendChild(emptyState);
  176.                 return;
  177.             }
  178.             
  179.             // 为每个待办事项创建列表项
  180.             todos.forEach(todo => {
  181.                 const li = document.createElement('li');
  182.                 li.className = 'todo-item';
  183.                
  184.                 // 创建复选框
  185.                 const checkbox = document.createElement('input');
  186.                 checkbox.type = 'checkbox';
  187.                 checkbox.checked = todo.completed;
  188.                 checkbox.addEventListener('change', () => toggleTodo(todo.id));
  189.                
  190.                 // 创建文本元素
  191.                 const text = document.createElement('span');
  192.                 text.className = 'todo-text';
  193.                 text.textContent = todo.text;
  194.                 if (todo.completed) {
  195.                     text.classList.add('completed');
  196.                 }
  197.                
  198.                 // 创建删除按钮
  199.                 const deleteBtn = document.createElement('button');
  200.                 deleteBtn.className = 'delete-btn';
  201.                 deleteBtn.textContent = '删除';
  202.                 deleteBtn.addEventListener('click', () => deleteTodo(todo.id));
  203.                
  204.                 // 添加元素到列表项
  205.                 li.appendChild(checkbox);
  206.                 li.appendChild(text);
  207.                 li.appendChild(deleteBtn);
  208.                
  209.                 // 添加列表项到列表
  210.                 todoList.appendChild(li);
  211.             });
  212.         }
  213.         
  214.         // 添加事件监听器
  215.         addBtn.addEventListener('click', addTodo);
  216.         
  217.         // 按Enter键添加待办事项
  218.         todoInput.addEventListener('keypress', function(event) {
  219.             if (event.key === 'Enter') {
  220.                 addTodo();
  221.             }
  222.         });
  223.         
  224.         // 初始渲染
  225.         renderTodos();
  226.     </script>
  227. </body>
  228. </html>
复制代码

动态表单生成器

创建一个可以动态添加和删除表单字段的表单生成器。
  2. <!DOCTYPE html>
  3. <html lang="zh-CN">
  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.         h1 {
  17.             text-align: center;
  18.             color: #333;
  19.         }
  20.         
  21.         .form-builder {
  22.             margin-bottom: 30px;
  23.             padding: 20px;
  24.             border: 1px solid #ddd;
  25.             border-radius: 5px;
  26.             background-color: #f9f9f9;
  27.         }
  28.         
  29.         .field-controls {
  30.             margin-bottom: 15px;
  31.         }
  32.         
  33.         .field-controls select,
  34.         .field-controls input {
  35.             padding: 8px;
  36.             margin-right: 10px;
  37.             border: 1px solid #ddd;
  38.             border-radius: 4px;
  39.         }
  40.         
  41.         .add-field-btn {
  42.             padding: 8px 15px;
  43.             background-color: #4CAF50;
  44.             color: white;
  45.             border: none;
  46.             border-radius: 4px;
  47.             cursor: pointer;
  48.         }
  49.         
  50.         .add-field-btn:hover {
  51.             background-color: #45a049;
  52.         }
  53.         
  54.         .form-preview {
  55.             padding: 20px;
  56.             border: 1px solid #ddd;
  57.             border-radius: 5px;
  58.             background-color: #fff;
  59.         }
  60.         
  61.         .form-field {
  62.             margin-bottom: 15px;
  63.         }
  64.         
  65.         .form-field label {
  66.             display: block;
  67.             margin-bottom: 5px;
  68.             font-weight: bold;
  69.         }
  70.         
  71.         .form-field input,
  72.         .form-field textarea,
  73.         .form-field select {
  74.             width: 100%;
  75.             padding: 8px;
  76.             box-sizing: border-box;
  77.             border: 1px solid #ddd;
  78.             border-radius: 4px;
  79.         }
  80.         
  81.         .form-field textarea {
  82.             resize: vertical;
  83.             min-height: 100px;
  84.         }
  85.         
  86.         .field-actions {
  87.             margin-top: 5px;
  88.         }
  89.         
  90.         .remove-field-btn {
  91.             padding: 5px 10px;
  92.             background-color: #f44336;
  93.             color: white;
  94.             border: none;
  95.             border-radius: 4px;
  96.             cursor: pointer;
  97.             font-size: 12px;
  98.         }
  99.         
  100.         .remove-field-btn:hover {
  101.             background-color: #d32f2f;
  102.         }
  103.         
  104.         .form-actions {
  105.             margin-top: 20px;
  106.             text-align: right;
  107.         }
  108.         
  109.         .submit-btn {
  110.             padding: 10px 20px;
  111.             background-color: #2196F3;
  112.             color: white;
  113.             border: none;
  114.             border-radius: 4px;
  115.             cursor: pointer;
  116.             font-size: 16px;
  117.         }
  118.         
  119.         .submit-btn:hover {
  120.             background-color: #0b7dda;
  121.         }
  122.         
  123.         .form-data {
  124.             margin-top: 30px;
  125.             padding: 15px;
  126.             border: 1px solid #ddd;
  127.             border-radius: 5px;
  128.             background-color: #f9f9f9;
  129.             display: none;
  130.         }
  131.         
  132.         .form-data h3 {
  133.             margin-top: 0;
  134.         }
  135.         
  136.         .form-data pre {
  137.             background-color: #eee;
  138.             padding: 10px;
  139.             border-radius: 4px;
  140.             white-space: pre-wrap;
  141.         }
  142.     </style>
  143. </head>
  144. <body>
  145.     <h1>动态表单生成器</h1>
  146.    
  147.     <div class="form-builder">
  148.         <h2>表单构建器</h2>
  149.         <div class="field-controls">
  150.             <select id="fieldType">
  151.                 <option value="text">文本输入</option>
  152.                 <option value="email">邮箱</option>
  153.                 <option value="password">密码</option>
  154.                 <option value="number">数字</option>
  155.                 <option value="textarea">文本区域</option>
  156.                 <option value="select">下拉选择</option>
  157.                 <option value="checkbox">复选框</option>
  158.                 <option value="radio">单选按钮</option>
  159.             </select>
  160.             <input type="text" id="fieldLabel" placeholder="字段标签">
  161.             <input type="text" id="fieldName" placeholder="字段名称">
  162.             <button id="addFieldBtn" class="add-field-btn">添加字段</button>
  163.         </div>
  164.     </div>
  165.    
  166.     <div class="form-preview">
  167.         <h2>表单预览</h2>
  168.         <form id="dynamicForm">
  169.             <!-- 动态生成的表单字段将在这里显示 -->
  170.         </form>
  171.         <div class="form-actions">
  172.             <button type="button" id="submitBtn" class="submit-btn">提交表单</button>
  173.         </div>
  174.     </div>
  175.    
  176.     <div id="formData" class="form-data">
  177.         <h3>表单数据</h3>
  178.         <pre id="formDataOutput"></pre>
  179.     </div>
  181.     <script>
  182.         // 获取DOM元素
  183.         const fieldType = document.getElementById('fieldType');
  184.         const fieldLabel = document.getElementById('fieldLabel');
  185.         const fieldName = document.getElementById('fieldName');
  186.         const addFieldBtn = document.getElementById('addFieldBtn');
  187.         const dynamicForm = document.getElementById('dynamicForm');
  188.         const submitBtn = document.getElementById('submitBtn');
  189.         const formData = document.getElementById('formData');
  190.         const formDataOutput = document.getElementById('formDataOutput');
  191.         
  192.         // 存储表单字段
  193.         let formFields = [];
  194.         
  195.         // 添加表单字段
  196.         function addFormField() {
  197.             const type = fieldType.value;
  198.             const label = fieldLabel.value.trim();
  199.             const name = fieldName.value.trim();
  200.             
  201.             if (label === '' || name === '') {
  202.                 alert('请填写字段标签和名称');
  203.                 return;
  204.             }
  205.             
  206.             // 创建字段对象
  207.             const field = {
  208.                 id: Date.now(),
  209.                 type: type,
  210.                 label: label,
  211.                 name: name,
  212.                 options: type === 'select' || type === 'radio' ? getOptions() : []
  213.             };
  214.             
  215.             // 添加到字段数组
  216.             formFields.push(field);
  217.             
  218.             // 清空输入
  219.             fieldLabel.value = '';
  220.             fieldName.value = '';
  221.             
  222.             // 渲染表单
  223.             renderForm();
  224.         }
  225.         
  226.         // 获取选项（用于下拉选择、单选按钮等）
  227.         function getOptions() {
  228.             const options = [];
  229.             const optionCount = prompt('请输入选项数量:', '3');
  230.             
  231.             if (optionCount && !isNaN(optionCount)) {
  232.                 const count = parseInt(optionCount);
  233.                 for (let i = 0; i < count; i++) {
  234.                     const optionValue = prompt(`请输入选项 ${i + 1} 的值:`, `选项 ${i + 1}`);
  235.                     if (optionValue) {
  236.                         options.push(optionValue);
  237.                     }
  238.                 }
  239.             }
  240.             
  241.             return options;
  242.         }
  243.         
  244.         // 删除表单字段
  245.         function removeFormField(id) {
  246.             formFields = formFields.filter(field => field.id !== id);
  247.             renderForm();
  248.         }
  249.         
  250.         // 渲染表单
  251.         function renderForm() {
  252.             // 清空表单
  253.             dynamicForm.innerHTML = '';
  254.             
  255.             // 检查是否有字段
  256.             if (formFields.length === 0) {
  257.                 const emptyMessage = document.createElement('p');
  258.                 emptyMessage.textContent = '暂无表单字段，请添加字段';
  259.                 emptyMessage.style.textAlign = 'center';
  260.                 emptyMessage.style.color = '#888';
  261.                 dynamicForm.appendChild(emptyMessage);
  262.                 return;
  263.             }
  264.             
  265.             // 为每个字段创建表单元素
  266.             formFields.forEach(field => {
  267.                 const fieldDiv = document.createElement('div');
  268.                 fieldDiv.className = 'form-field';
  269.                
  270.                 // 创建标签
  271.                 const label = document.createElement('label');
  272.                 label.textContent = field.label;
  273.                 fieldDiv.appendChild(label);
  274.                
  275.                 // 根据字段类型创建不同的输入元素
  276.                 let inputElement;
  277.                
  278.                 switch (field.type) {
  279.                     case 'textarea':
  280.                         inputElement = document.createElement('textarea');
  281.                         inputElement.name = field.name;
  282.                         break;
  283.                         
  284.                     case 'select':
  285.                         inputElement = document.createElement('select');
  286.                         inputElement.name = field.name;
  287.                         
  288.                         // 添加默认选项
  289.                         const defaultOption = document.createElement('option');
  290.                         defaultOption.value = '';
  291.                         defaultOption.textContent = '请选择...';
  292.                         inputElement.appendChild(defaultOption);
  293.                         
  294.                         // 添加用户定义的选项
  295.                         field.options.forEach(option => {
  296.                             const optionElement = document.createElement('option');
  297.                             optionElement.value = option;
  298.                             optionElement.textContent = option;
  299.                             inputElement.appendChild(optionElement);
  300.                         });
  301.                         break;
  302.                         
  303.                     case 'checkbox':
  304.                         inputElement = document.createElement('input');
  305.                         inputElement.type = 'checkbox';
  306.                         inputElement.name = field.name;
  307.                         inputElement.value = 'yes';
  308.                         break;
  309.                         
  310.                     case 'radio':
  311.                         // 为单选按钮创建一个容器
  312.                         const radioContainer = document.createElement('div');
  313.                         
  314.                         field.options.forEach((option, index) => {
  315.                             const radioDiv = document.createElement('div');
  316.                             radioDiv.style.marginBottom = '5px';
  317.                            
  318.                             const radio = document.createElement('input');
  319.                             radio.type = 'radio';
  320.                             radio.name = field.name;
  321.                             radio.value = option;
  322.                             radio.id = `${field.name}_${index}`;
  323.                            
  324.                             const radioLabel = document.createElement('label');
  325.                             radioLabel.textContent = option;
  326.                             radioLabel.htmlFor = `${field.name}_${index}`;
  327.                             radioLabel.style.marginLeft = '5px';
  328.                             radioLabel.style.fontWeight = 'normal';
  329.                            
  330.                             radioDiv.appendChild(radio);
  331.                             radioDiv.appendChild(radioLabel);
  332.                             radioContainer.appendChild(radioDiv);
  333.                         });
  334.                         
  335.                         fieldDiv.appendChild(radioContainer);
  336.                         break;
  337.                         
  338.                     default:
  339.                         inputElement = document.createElement('input');
  340.                         inputElement.type = field.type;
  341.                         inputElement.name = field.name;
  342.                 }
  343.                
  344.                 // 如果不是单选按钮，添加输入元素
  345.                 if (field.type !== 'radio') {
  346.                     fieldDiv.appendChild(inputElement);
  347.                 }
  348.                
  349.                 // 添加删除按钮
  350.                 const actionsDiv = document.createElement('div');
  351.                 actionsDiv.className = 'field-actions';
  352.                
  353.                 const removeBtn = document.createElement('button');
  354.                 removeBtn.type = 'button';
  355.                 removeBtn.className = 'remove-field-btn';
  356.                 removeBtn.textContent = '删除字段';
  357.                 removeBtn.addEventListener('click', () => removeFormField(field.id));
  358.                
  359.                 actionsDiv.appendChild(removeBtn);
  360.                 fieldDiv.appendChild(actionsDiv);
  361.                
  362.                 // 添加字段到表单
  363.                 dynamicForm.appendChild(fieldDiv);
  364.             });
  365.         }
  366.         
  367.         // 提交表单
  368.         function submitForm() {
  369.             if (formFields.length === 0) {
  370.                 alert('表单没有字段，无法提交');
  371.                 return;
  372.             }
  373.             
  374.             // 创建FormData对象
  375.             const formData = new FormData(dynamicForm);
  376.             
  377.             // 转换为普通对象
  378.             const formDataObj = {};
  379.             
  380.             // 处理常规字段
  381.             for (let [key, value] of formData.entries()) {
  382.                 // 如果字段已存在，转换为数组
  383.                 if (formDataObj[key]) {
  384.                     if (!Array.isArray(formDataObj[key])) {
  385.                         formDataObj[key] = [formDataObj[key]];
  386.                     }
  387.                     formDataObj[key].push(value);
  388.                 } else {
  389.                     formDataObj[key] = value;
  390.                 }
  391.             }
  392.             
  393.             // 处理复选框（如果未选中，不会包含在FormData中）
  394.             formFields.forEach(field => {
  395.                 if (field.type === 'checkbox' && !formDataObj[field.name]) {
  396.                     formDataObj[field.name] = 'no';
  397.                 }
  398.             });
  399.             
  400.             // 显示表单数据
  401.             formData.style.display = 'block';
  402.             formDataOutput.textContent = JSON.stringify(formDataObj, null, 2);
  403.         }
  404.         
  405.         // 添加事件监听器
  406.         addFieldBtn.addEventListener('click', addFormField);
  407.         submitBtn.addEventListener('click', submitForm);
  408.         
  409.         // 初始渲染
  410.         renderForm();
  411.     </script>
  412. </body>
  413. </html>
复制代码

实时搜索过滤器

创建一个实时搜索过滤器，可以根据用户输入过滤列表项。
  2. <!DOCTYPE html>
  3. <html lang="zh-CN">
  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.         h1 {
  17.             text-align: center;
  18.             color: #333;
  19.         }
  20.         
  21.         .search-container {
  22.             margin-bottom: 20px;
  23.         }
  24.         
  25.         #searchInput {
  26.             width: 100%;
  27.             padding: 12px;
  28.             border: 1px solid #ddd;
  29.             border-radius: 4px;
  30.             font-size: 16px;
  31.             box-sizing: border-box;
  32.         }
  33.         
  34.         .filter-options {
  35.             margin: 15px 0;
  36.             display: flex;
  37.             flex-wrap: wrap;
  38.             gap: 10px;
  39.         }
  40.         
  41.         .filter-option {
  42.             display: flex;
  43.             align-items: center;
  44.         }
  45.         
  46.         .filter-option input {
  47.             margin-right: 5px;
  48.         }
  49.         
  50.         .item-list {
  51.             list-style: none;
  52.             padding: 0;
  53.         }
  54.         
  55.         .item {
  56.             padding: 15px;
  57.             border-bottom: 1px solid #eee;
  58.             display: flex;
  59.             align-items: center;
  60.         }
  61.         
  62.         .item:last-child {
  63.             border-bottom: none;
  64.         }
  65.         
  66.         .item-icon {
  67.             width: 50px;
  68.             height: 50px;
  69.             border-radius: 50%;
  70.             background-color: #4CAF50;
  71.             color: white;
  72.             display: flex;
  73.             align-items: center;
  74.             justify-content: center;
  75.             font-weight: bold;
  76.             margin-right: 15px;
  77.             flex-shrink: 0;
  78.         }
  79.         
  80.         .item-content {
  81.             flex: 1;
  82.         }
  83.         
  84.         .item-title {
  85.             font-weight: bold;
  86.             margin-bottom: 5px;
  87.         }
  88.         
  89.         .item-description {
  90.             color: #666;
  91.             font-size: 14px;
  92.         }
  93.         
  94.         .item-category {
  95.             display: inline-block;
  96.             padding: 3px 8px;
  97.             background-color: #e0e0e0;
  98.             border-radius: 12px;
  99.             font-size: 12px;
  100.             margin-top: 5px;
  101.         }
  102.         
  103.         .no-results {
  104.             text-align: center;
  105.             padding: 30px;
  106.             color: #888;
  107.             font-style: italic;
  108.         }
  109.         
  110.         .highlight {
  111.             background-color: yellow;
  112.             font-weight: bold;
  113.         }
  114.         
  115.         .stats {
  116.             margin-top: 20px;
  117.             padding: 10px;
  118.             background-color: #f5f5f5;
  119.             border-radius: 4px;
  120.             text-align: center;
  121.         }
  122.     </style>
  123. </head>
  124. <body>
  125.     <h1>实时搜索过滤器</h1>
  126.    
  127.     <div class="search-container">
  128.         <input type="text" id="searchInput" placeholder="搜索项目...">
  129.     </div>
  130.    
  131.     <div class="filter-options">
  132.         <div class="filter-option">
  133.             <input type="checkbox" id="filterFruits" value="水果" checked>
  134.             <label for="filterFruits">水果</label>
  135.         </div>
  136.         <div class="filter-option">
  137.             <input type="checkbox" id="filterVegetables" value="蔬菜" checked>
  138.             <label for="filterVegetables">蔬菜</label>
  139.         </div>
  140.         <div class="filter-option">
  141.             <input type="checkbox" id="filterGrains" value="谷物" checked>
  142.             <label for="filterGrains">谷物</label>
  143.         </div>
  144.         <div class="filter-option">
  145.             <input type="checkbox" id="filterProteins" value="蛋白质" checked>
  146.             <label for="filterProteins">蛋白质</label>
  147.         </div>
  148.     </div>
  149.    
  150.     <ul id="itemList" class="item-list">
  151.         <!-- 项目将通过JavaScript动态生成 -->
  152.     </ul>
  153.    
  154.     <div id="stats" class="stats">
  155.         显示 0 / 0 个项目
  156.     </div>
  158.     <script>
  159.         // 示例数据
  160.         const items = [
  161.             { id: 1, title: '苹果', description: '富含维生素C和纤维的水果', category: '水果' },
  162.             { id: 2, title: '香蕉', description: '富含钾的热带水果', category: '水果' },
  163.             { id: 3, title: '橙子', description: '富含维生素C的柑橘类水果', category: '水果' },
  164.             { id: 4, title: '草莓', description: '富含抗氧化剂的浆果', category: '水果' },
  165.             { id: 5, title: '胡萝卜', description: '富含维生素A的根茎蔬菜', category: '蔬菜' },
  166.             { id: 6, title: '西兰花', description: '富含维生素K和C的绿色蔬菜', category: '蔬菜' },
  167.             { id: 7, title: '菠菜', description: '富含铁和叶酸的绿叶蔬菜', category: '蔬菜' },
  168.             { id: 8, title: '番茄', description: '富含番茄红素的红色蔬果', category: '蔬菜' },
  169.             { id: 9, title: '大米', description: '主要的主食谷物', category: '谷物' },
  170.             { id: 10, title: '小麦', description: '制作面包和面食的谷物', category: '谷物' },
  171.             { id: 11, title: '燕麦', description: '富含可溶性纤维的谷物', category: '谷物' },
  172.             { id: 12, title: '玉米', description: '多用途的谷物', category: '谷物' },
  173.             { id: 13, title: '鸡肉', description: '优质蛋白质来源', category: '蛋白质' },
  174.             { id: 14, title: '鱼类', description: '富含Omega-3脂肪酸的蛋白质', category: '蛋白质' },
  175.             { id: 15, title: '豆腐', description: '植物性蛋白质来源', category: '蛋白质' },
  176.             { id: 16, title: '鸡蛋', description: '完整蛋白质来源', category: '蛋白质' }
  177.         ];
  178.         
  179.         // 获取DOM元素
  180.         const searchInput = document.getElementById('searchInput');
  181.         const filterOptions = document.querySelectorAll('.filter-option input');
  182.         const itemList = document.getElementById('itemList');
  183.         const stats = document.getElementById('stats');
  184.         
  185.         // 获取选中的类别
  186.         function getSelectedCategories() {
  187.             const selectedCategories = [];
  188.             filterOptions.forEach(option => {
  189.                 if (option.checked) {
  190.                     selectedCategories.push(option.value);
  191.                 }
  192.             });
  193.             return selectedCategories;
  194.         }
  195.         
  196.         // 高亮匹配的文本
  197.         function highlightText(text, searchTerm) {
  198.             if (!searchTerm) return text;
  199.             
  200.             const regex = new RegExp(`(${searchTerm})`, 'gi');
  201.             return text.replace(regex, '<span class="highlight">$1</span>');
  202.         }
  203.         
  204.         // 渲染项目列表
  205.         function renderItems() {
  206.             const searchTerm = searchInput.value.trim().toLowerCase();
  207.             const selectedCategories = getSelectedCategories();
  208.             
  209.             // 过滤项目
  210.             const filteredItems = items.filter(item => {
  211.                 // 检查类别是否被选中
  212.                 if (!selectedCategories.includes(item.category)) {
  213.                     return false;
  214.                 }
  215.                
  216.                 // 检查是否匹配搜索词
  217.                 if (searchTerm) {
  218.                     const titleMatch = item.title.toLowerCase().includes(searchTerm);
  219.                     const descriptionMatch = item.description.toLowerCase().includes(searchTerm);
  220.                     return titleMatch || descriptionMatch;
  221.                 }
  222.                
  223.                 return true;
  224.             });
  225.             
  226.             // 清空列表
  227.             itemList.innerHTML = '';
  228.             
  229.             // 检查是否有结果
  230.             if (filteredItems.length === 0) {
  231.                 const noResults = document.createElement('li');
  232.                 noResults.className = 'no-results';
  233.                 noResults.textContent = '没有找到匹配的项目';
  234.                 itemList.appendChild(noResults);
  235.             } else {
  236.                 // 渲染每个项目
  237.                 filteredItems.forEach(item => {
  238.                     const li = document.createElement('li');
  239.                     li.className = 'item';
  240.                     
  241.                     // 创建图标（使用首字母）
  242.                     const icon = document.createElement('div');
  243.                     icon.className = 'item-icon';
  244.                     icon.textContent = item.title.charAt(0);
  245.                     
  246.                     // 根据类别设置不同的背景色
  247.                     switch (item.category) {
  248.                         case '水果':
  249.                             icon.style.backgroundColor = '#FF9800';
  250.                             break;
  251.                         case '蔬菜':
  252.                             icon.style.backgroundColor = '#4CAF50';
  253.                             break;
  254.                         case '谷物':
  255.                             icon.style.backgroundColor = '#FFC107';
  256.                             break;
  257.                         case '蛋白质':
  258.                             icon.style.backgroundColor = '#F44336';
  259.                             break;
  260.                     }
  261.                     
  262.                     // 创建内容区域
  263.                     const content = document.createElement('div');
  264.                     content.className = 'item-content';
  265.                     
  266.                     // 创建标题（高亮匹配的文本）
  267.                     const title = document.createElement('div');
  268.                     title.className = 'item-title';
  269.                     title.innerHTML = highlightText(item.title, searchTerm);
  270.                     
  271.                     // 创建描述（高亮匹配的文本）
  272.                     const description = document.createElement('div');
  273.                     description.className = 'item-description';
  274.                     description.innerHTML = highlightText(item.description, searchTerm);
  275.                     
  276.                     // 创建类别标签
  277.                     const category = document.createElement('div');
  278.                     category.className = 'item-category';
  279.                     category.textContent = item.category;
  280.                     
  281.                     // 组装内容
  282.                     content.appendChild(title);
  283.                     content.appendChild(description);
  284.                     content.appendChild(category);
  285.                     
  286.                     // 组装项目
  287.                     li.appendChild(icon);
  288.                     li.appendChild(content);
  289.                     
  290.                     // 添加到列表
  291.                     itemList.appendChild(li);
  292.                 });
  293.             }
  294.             
  295.             // 更新统计信息
  296.             updateStats(filteredItems.length, items.length);
  297.         }
  298.         
  299.         // 更新统计信息
  300.         function updateStats(visibleCount, totalCount) {
  301.             stats.textContent = `显示 ${visibleCount} / ${totalCount} 个项目`;
  302.         }
  303.         
  304.         // 添加事件监听器
  305.         searchInput.addEventListener('input', renderItems);
  306.         
  307.         filterOptions.forEach(option => {
  308.             option.addEventListener('change', renderItems);
  309.         });
  310.         
  311.         // 初始渲染
  312.         renderItems();
  313.     </script>
  314. </body>
  315. </html>
复制代码

最佳实践和性能优化

避免频繁的DOM操作

频繁的DOM操作会导致性能问题，因为每次操作都可能引起浏览器的重排或重绘。
  2. <div id="container"></div>
  3. <button id="addItemsBtn">添加1000个项目</button>
  5. <script>
  6.     const container = document.getElementById('container');
  7.     const addItemsBtn = document.getElementById('addItemsBtn');
  8.    
  9.     addItemsBtn.addEventListener('click', function() {
  10.         // 不好的做法：频繁操作DOM
  11.         // for (let i = 0; i < 1000; i++) {
  12.         //     const item = document.createElement('div');
  13.         //     item.textContent = `项目 ${i + 1}`;
  14.         //     container.appendChild(item);
  15.         // }
  16.         
  17.         // 好的做法：使用文档片段减少DOM操作
  18.         const fragment = document.createDocumentFragment();
  19.         
  20.         for (let i = 0; i < 1000; i++) {
  21.             const item = document.createElement('div');
  22.             item.textContent = `项目 ${i + 1}`;
  23.             fragment.appendChild(item);
  24.         }
  25.         
  26.         container.appendChild(fragment);
  27.     });
  28. </script>
复制代码

使用事件委托

当有大量元素需要相同的事件处理时，使用事件委托可以减少内存使用和提高性能。
  2. <ul id="list">
  3.     <!-- 动态生成的列表项 -->
  4. </ul>
  5. <button id="addItemBtn">添加项目</button>
  7. <script>
  8.     const list = document.getElementById('list');
  9.     const addItemBtn = document.getElementById('addItemBtn');
  10.     let itemCount = 0;
  11.    
  12.     // 添加项目
  13.     addItemBtn.addEventListener('click', function() {
  14.         itemCount++;
  15.         const item = document.createElement('li');
  16.         item.textContent = `项目 ${itemCount}`;
  17.         item.className = 'list-item';
  18.         list.appendChild(item);
  19.     });
  20.    
  21.     // 不好的做法：为每个列表项单独添加事件监听器
  22.     // function addItemClickListeners() {
  23.     //     const items = document.querySelectorAll('.list-item');
  24.     //     items.forEach(item => {
  25.     //         item.addEventListener('click', function() {
  26.     //             console.log(`点击了: ${this.textContent}`);
  27.     //         });
  28.     //     });
  29.     // }
  30.    
  31.     // 好的做法：使用事件委托
  32.     list.addEventListener('click', function(event) {
  33.         // 检查点击的是否是列表项
  34.         if (event.target.tagName === 'LI') {
  35.             console.log(`点击了: ${event.target.textContent}`);
  36.         }
  37.     });
  38. </script>
复制代码

避免强制同步布局

强制同步布局（Layout Thrashing）是指JavaScript强制浏览器在执行过程中重新计算布局，这会导致性能问题。
  2. <div id="box" style="width: 100px; height: 100px; background-color: blue;"></div>
  3. <button id="animateBtn">动画</button>
  5. <script>
  6.     const box = document.getElementById('box');
  7.     const animateBtn = document.getElementById('animateBtn');
  8.    
  9.     animateBtn.addEventListener('click', function() {
  10.         // 不好的做法：强制同步布局
  11.         // for (let i = 0; i < 100; i++) {
  12.         //     box.style.width = (100 + i) + 'px';
  13.         //     // 读取宽度会导致强制同步布局
  14.         //     console.log(box.offsetWidth);
  15.         // }
  16.         
  17.         // 好的做法：批量读取和写入
  18.         let width = 100;
  19.         
  20.         // 先读取所有需要的值
  21.         const startWidth = box.offsetWidth;
  22.         
  23.         // 然后批量写入
  24.         for (let i = 0; i < 100; i++) {
  25.             width++;
  26.             box.style.width = width + 'px';
  27.         }
  28.         
  29.         // 最后读取最终值
  30.         console.log('最终宽度:', box.offsetWidth);
  31.     });
  32. </script>
复制代码

使用requestAnimationFrame进行动画

使用requestAnimationFrame而不是setTimeout或setInterval进行动画，可以获得更好的性能和更流畅的动画效果。
  2. <div id="animatedBox" style="width: 50px; height: 50px; background-color: red; position: absolute; top: 0; left: 0;"></div>
  3. <button id="startAnimationBtn">开始动画</button>
  5. <script>
  6.     const animatedBox = document.getElementById('animatedBox');
  7.     const startAnimationBtn = document.getElementById('startAnimationBtn');
  8.     let animationId = null;
  9.     let position = 0;
  10.    
  11.     startAnimationBtn.addEventListener('click', function() {
  12.         if (animationId) {
  13.             // 如果动画已经在运行，先停止
  14.             cancelAnimationFrame(animationId);
  15.             animationId = null;
  16.             startAnimationBtn.textContent = '开始动画';
  17.         } else {
  18.             // 开始动画
  19.             startAnimationBtn.textContent = '停止动画';
  20.             animate();
  21.         }
  22.     });
  23.    
  24.     function animate() {
  25.         // 更新位置
  26.         position += 2;
  27.         
  28.         // 如果超出边界，重置位置
  29.         if (position > window.innerWidth - 50) {
  30.             position = 0;
  31.         }
  32.         
  33.         // 更新元素位置
  34.         animatedBox.style.left = position + 'px';
  35.         
  36.         // 请求下一帧
  37.         animationId = requestAnimationFrame(animate);
  38.     }
  39. </script>
复制代码

使用虚拟滚动处理大量数据

当需要渲染大量数据时，使用虚拟滚动技术只渲染可见区域的项目，可以大大提高性能。
  2. <!DOCTYPE html>
  3. <html lang="zh-CN">
  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.             margin: 0;
  12.             padding: 20px;
  13.         }
  14.         
  15.         h1 {
  16.             text-align: center;
  17.         }
  18.         
  19.         .scroll-container {
  20.             height: 400px;
  21.             overflow-y: auto;
  22.             border: 1px solid #ddd;
  23.             position: relative;
  24.         }
  25.         
  26.         .scroll-content {
  27.             position: relative;
  28.         }
  29.         
  30.         .scroll-item {
  31.             padding: 15px;
  32.             border-bottom: 1px solid #eee;
  33.             box-sizing: border-box;
  34.             height: 50px;
  35.         }
  36.         
  37.         .scroll-item:nth-child(odd) {
  38.             background-color: #f9f9f9;
  39.         }
  40.         
  41.         .info {
  42.             margin-top: 10px;
  43.             text-align: center;
  44.             color: #666;
  45.         }
  46.     </style>
  47. </head>
  48. <body>
  49.     <h1>虚拟滚动示例</h1>
  50.    
  51.     <div id="scrollContainer" class="scroll-container">
  52.         <div id="scrollContent" class="scroll-content">
  53.             <!-- 虚拟滚动项将在这里动态生成 -->
  54.         </div>
  55.     </div>
  56.    
  57.     <div id="info" class="info">
  58.         显示 0 / 0 个项目
  59.     </div>
  61.     <script>
  62.         // 配置
  63.         const config = {
  64.             itemHeight: 50,       // 每个项目的高度
  65.             bufferSize: 5,        // 上下缓冲的项目数量
  66.             totalItems: 10000     // 总项目数
  67.         };
  68.         
  69.         // 获取DOM元素
  70.         const scrollContainer = document.getElementById('scrollContainer');
  71.         const scrollContent = document.getElementById('scrollContent');
  72.         const info = document.getElementById('info');
  73.         
  74.         // 状态
  75.         let scrollTop = 0;
  76.         let visibleStartIndex = 0;
  77.         let visibleEndIndex = 0;
  78.         
  79.         // 初始化
  80.         function init() {
  81.             // 设置滚动内容的高度
  82.             scrollContent.style.height = `${config.itemHeight * config.totalItems}px`;
  83.             
  84.             // 监听滚动事件
  85.             scrollContainer.addEventListener('scroll', handleScroll);
  86.             
  87.             // 初始渲染
  88.             renderVisibleItems();
  89.         }
  90.         
  91.         // 处理滚动事件
  92.         function handleScroll() {
  93.             scrollTop = scrollContainer.scrollTop;
  94.             
  95.             // 计算可见区域的起始和结束索引
  96.             visibleStartIndex = Math.floor(scrollTop / config.itemHeight);
  97.             visibleEndIndex = Math.min(
  98.                 visibleStartIndex + Math.ceil(scrollContainer.clientHeight / config.itemHeight),
  99.                 config.totalItems - 1
  100.             );
  101.             
  102.             // 添加缓冲区
  103.             const bufferedStartIndex = Math.max(0, visibleStartIndex - config.bufferSize);
  104.             const bufferedEndIndex = Math.min(config.totalItems - 1, visibleEndIndex + config.bufferSize);
  105.             
  106.             // 渲染可见项目
  107.             renderItems(bufferedStartIndex, bufferedEndIndex);
  108.             
  109.             // 更新信息
  110.             updateInfo();
  111.         }
  112.         
  113.         // 渲染指定范围的项目
  114.         function renderItems(startIndex, endIndex) {
  115.             // 清空当前内容
  116.             scrollContent.innerHTML = '';
  117.             
  118.             // 设置内容的位置
  119.             scrollContent.style.transform = `translateY(${startIndex * config.itemHeight}px)`;
  120.             
  121.             // 渲染项目
  122.             for (let i = startIndex; i <= endIndex; i++) {
  123.                 const item = createItem(i);
  124.                 scrollContent.appendChild(item);
  125.             }
  126.         }
  127.         
  128.         // 创建单个项目
  129.         function createItem(index) {
  130.             const item = document.createElement('div');
  131.             item.className = 'scroll-item';
  132.             item.textContent = `项目 ${index + 1}`;
  133.             return item;
  134.         }
  135.         
  136.         // 渲染可见项目（初始调用）
  137.         function renderVisibleItems() {
  138.             visibleEndIndex = Math.min(
  139.                 Math.ceil(scrollContainer.clientHeight / config.itemHeight),
  140.                 config.totalItems - 1
  141.             );
  142.             
  143.             renderItems(visibleStartIndex, visibleEndIndex);
  144.             updateInfo();
  145.         }
  146.         
  147.         // 更新信息
  148.         function updateInfo() {
  149.             const visibleCount = visibleEndIndex - visibleStartIndex + 1;
  150.             info.textContent = `显示 ${visibleCount} / ${config.totalItems} 个项目 (索引: ${visibleStartIndex}-${visibleEndIndex})`;
  151.         }
  152.         
  153.         // 初始化虚拟滚动
  154.         init();
  155.     </script>
  156. </body>
  157. </html>
复制代码

结论

JavaScript操作DOM是动态网页开发的核心技能。通过本教程，我们学习了如何选择DOM元素、修改元素内容和属性、处理用户事件以及创建动态交互效果。通过实际案例，我们掌握了待办事项列表、动态表单生成器和实时搜索过滤器的实现方法。同时，我们也了解了DOM操作的最佳实践和性能优化技巧，如避免频繁DOM操作、使用事件委托、避免强制同步布局、使用requestAnimationFrame进行动画以及虚拟滚动处理大量数据。

掌握这些技能后，你将能够创建更加动态、交互式和高性能的Web应用。记住，实践是掌握这些技能的关键，所以请尝试将这些技术应用到你的项目中，不断探索和学习新的DOM操作技巧。
回复

使用道具 举报

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

本版积分规则

友情链接

keba
磕巴白菜
别管 别听 就是玩
二次元论坛
二次元论坛
按下F逃离世界！
次元宅社
次元宅社
开放、共创，CHANGE SEKAI！
频道订阅

频道订阅

加入社群

加入社群

联系我们|TG频道|RSS

Powered by Pixtech

© 2025 Pixtech Team.