活动公告

系统通知
通知：本站资源由网友上传分享，如有违规等问题请到版务模块进行投诉，资源失效请在帖子内回复要求补档，会尽快处理！
10-23 09:31
>社区 > 科技 > 经验交流 >帖子
本版发帖返回

掌握HTML DOM属性访问技巧提升网页交互性能从基础到进阶全面解析属性获取与修改方法助你成为前端开发高手

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

3万

主题

2720

科技点

3万

积分

执行版主

碾压王

积分
32881

塔罗立华奏
执行版主 发表于 2025-8-31 15:10:00 | 显示全部楼层 |阅读模式

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

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

x
引言

在现代Web开发中，文档对象模型（DOM）扮演着至关重要的角色。它是HTML和XML文档的编程接口，允许开发者和程序动态地访问和更新文档的内容、结构和样式。掌握DOM属性访问技巧不仅能提升网页的交互性能，还能帮助开发者构建更加高效、响应迅速的用户界面。本文将从基础到进阶，全面解析DOM属性的获取与修改方法，助你成为前端开发高手。

DOM基础：理解文档对象模型

什么是DOM

DOM（Document Object Model）是HTML和XML文档的编程接口，它将文档表示为一个节点树，其中每个节点代表文档的一部分（如元素、属性、文本等）。通过DOM，开发者可以使用脚本语言（如JavaScript）动态地访问和修改文档的各个方面。
  2. <!DOCTYPE html>
  3. <html>
  4. <head>
  5.     <title>示例页面</title>
  6. </head>
  7. <body>
  8.     <h1>欢迎来到DOM世界</h1>
  9.     <p>这是一个关于DOM的示例段落。</p>
  10. </body>
  11. </html>
复制代码

上述HTML代码对应的DOM树结构如下：
  2. Document
  3. └── html
  4.      ├── head
  5.      │   └── title
  6.      │       └── "示例页面"
  7.      └── body
  8.          ├── h1
  9.          │   └── "欢迎来到DOM世界"
  10.          └── p
  11.              └── "这是一个关于DOM的示例段落。"
复制代码

DOM节点类型

DOM中包含多种节点类型，常见的有：

1. 元素节点（Element Node）：表示HTML元素，如<div>、<p>等。
2. 属性节点（Attribute Node）：表示元素的属性，如id、class等。
3. 文本节点（Text Node）：表示元素中的文本内容。
4. 文档节点（Document Node）：表示整个文档。

基础DOM属性访问方法

直接属性访问

最简单的DOM属性访问方式是通过JavaScript对象的属性直接访问。这种方式适用于大多数标准HTML属性。
  2. // 获取元素
  3. const element = document.getElementById('myElement');
  5. // 访问和修改属性
  6. element.id = 'newId';           // 修改id属性
  7. element.className = 'newClass'; // 修改class属性
  8. element.href = 'https://example.com'; // 修改a标签的href属性
  10. // 访问属性值
  11. const id = element.id;          // 获取id属性值
  12. const className = element.className; // 获取class属性值
复制代码

getAttribute()和setAttribute()方法

对于非标准属性或需要更精确控制的场景，可以使用getAttribute()和setAttribute()方法。
  2. // 获取元素
  3. const element = document.getElementById('myElement');
  5. // 使用getAttribute获取属性值
  6. const id = element.getAttribute('id');
  7. const dataValue = element.getAttribute('data-custom');
  9. // 使用setAttribute设置属性值
  10. element.setAttribute('id', 'newId');
  11. element.setAttribute('data-custom', 'customValue');
复制代码

属性（Property）与属性（Attribute）的区别

在DOM操作中，理解属性（Property）和属性（Attribute）的区别非常重要：

• 属性（Attribute）：是HTML标签中定义的属性，如<div id="myDiv" class="container">中的id和class。
• 属性（Property）：是DOM对象的属性，是JavaScript中的概念。

大多数情况下，属性（Attribute）和属性（Property）是同步的，但也有一些例外：
  2. <input type="checkbox" id="myCheckbox" checked>
复制代码
  2. const checkbox = document.getElementById('myCheckbox');
  4. // 获取属性值（Attribute）
  5. console.log(checkbox.getAttribute('checked')); // 返回 "checked"（初始状态）
  7. // 获取属性值（Property）
  8. console.log(checkbox.checked); // 返回 true（当前状态）
  10. // 修改属性（Property）
  11. checkbox.checked = false; // 复选框取消选中
  12. console.log(checkbox.getAttribute('checked')); // 仍然返回 "checked"
  13. console.log(checkbox.checked); // 返回 false
  15. // 修改属性（Attribute）
  16. checkbox.setAttribute('checked', 'checked'); // 复选框被选中
  17. console.log(checkbox.checked); // 返回 true
复制代码

进阶DOM属性操作技巧

批量属性操作

当需要同时操作多个属性时，可以使用Object.assign()或自定义函数来批量设置属性，减少DOM操作次数，提升性能。
  2. // 方法1：使用Object.assign()
  3. const element = document.getElementById('myElement');
  4. Object.assign(element, {
  5.     id: 'newId',
  6.     className: 'newClass anotherClass',
  7.     style: {
  8.         color: 'red',
  9.         fontSize: '16px'
  10.     }
  11. });
  13. // 方法2：自定义批量设置属性函数
  14. function setAttributes(el, attrs) {
  15.     for (let key in attrs) {
  16.         if (attrs.hasOwnProperty(key)) {
  17.             if (key === 'style' && typeof attrs[key] === 'object') {
  18.                 // 处理样式对象
  19.                 Object.assign(el.style, attrs[key]);
  20.             } else {
  21.                 el.setAttribute(key, attrs[key]);
  22.             }
  23.         }
  24.     }
  25. }
  27. // 使用自定义函数
  28. setAttributes(element, {
  29.     'data-id': '123',
  30.     'data-name': 'example',
  31.     'aria-label': 'Example element',
  32.     style: {
  33.         backgroundColor: '#f0f0f0',
  34.         padding: '10px'
  35.     }
  36. });
复制代码

性能优化的属性访问方法

频繁的DOM操作会导致性能问题，以下是一些优化技巧：
  2. // 不好的做法：每次都查询DOM
  3. function updateItems() {
  4.     const items = document.querySelectorAll('.item');
  5.     items.forEach(item => {
  6.         item.style.color = 'red';
  7.     });
  8. }
  10. // 好的做法：缓存DOM引用
  11. const items = document.querySelectorAll('.item');
  12. function updateItems() {
  13.     items.forEach(item => {
  14.         item.style.color = 'red';
  15.     });
  16. }
复制代码
  2. // 不好的做法：多次DOM操作
  3. const list = document.getElementById('list');
  4. for (let i = 0; i < 100; i++) {
  5.     const item = document.createElement('li');
  6.     item.textContent = `Item ${i}`;
  7.     list.appendChild(item);
  8. }
  10. // 好的做法：使用DocumentFragment
  11. const list = document.getElementById('list');
  12. const fragment = document.createDocumentFragment();
  13. for (let i = 0; i < 100; i++) {
  14.     const item = document.createElement('li');
  15.     item.textContent = `Item ${i}`;
  16.     fragment.appendChild(item);
  17. }
  18. list.appendChild(fragment);
复制代码
  2. // 不好的做法：直接修改样式
  3. element.style.width = '100px';
  4. element.style.height = '100px';
  5. element.style.backgroundColor = 'red';
  7. // 好的做法：使用requestAnimationFrame
  8. requestAnimationFrame(() => {
  9.     element.style.width = '100px';
  10.     element.style.height = '100px';
  11.     element.style.backgroundColor = 'red';
  12. });
复制代码

自定义属性(data-*)的使用

HTML5引入了自定义数据属性（data-*），允许在HTML元素上存储自定义数据，这些数据不会影响页面的呈现，但可以通过JavaScript访问。
  2. <div id="user" data-id="123" data-name="John Doe" data-email="john@example.com"></div>
复制代码
  2. // 获取元素
  3. const user = document.getElementById('user');
  5. // 使用getAttribute访问
  6. const userId = user.getAttribute('data-id'); // "123"
  7. const userName = user.getAttribute('data-name'); // "John Doe"
  9. // 使用dataset属性访问（更简洁）
  10. const userId2 = user.dataset.id; // "123"
  11. const userName2 = user.dataset.name; // "John Doe"
  13. // 修改自定义属性
  14. user.dataset.id = '456'; // 修改data-id
  15. user.dataset.role = 'admin'; // 添加data-role
  17. // 删除自定义属性
  18. delete user.dataset.role; // 删除data-role
复制代码

自定义属性在实际开发中有很多用途，例如：

1. 存储与元素相关的数据
2. 实现组件状态管理
3. 传递配置参数
  2. // 示例：使用data-*属性实现简单的选项卡组件
  3. const tabs = document.querySelectorAll('.tab');
  4. const contents = document.querySelectorAll('.tab-content');
  6. tabs.forEach(tab => {
  7.     tab.addEventListener('click', () => {
  8.         const targetId = tab.dataset.target;
  9.         
  10.         // 隐藏所有内容
  11.         contents.forEach(content => {
  12.             content.style.display = 'none';
  13.         });
  14.         
  15.         // 显示目标内容
  16.         document.getElementById(targetId).style.display = 'block';
  17.         
  18.         // 更新选项卡样式
  19.         tabs.forEach(t => t.classList.remove('active'));
  20.         tab.classList.add('active');
  21.     });
  22. });
复制代码

DOM属性与性能

重排（Reflow）与重绘（Repaint）

理解重排和重绘对于优化DOM操作性能至关重要：

• 重排（Reflow）：当DOM的变化影响了元素的几何属性（宽、高、位置等），浏览器需要重新计算元素的几何属性，其他元素的几何属性和位置也会因此受到影响。浏览器会使渲染树中受到影响的部分失效，并重新构造渲染树。这个过程称为重排。
• 重绘（Repaint）：当元素的外观发生变化，但没有影响布局，浏览器会将元素的新外观绘制到屏幕上。这个过程称为重绘。

重排（Reflow）：当DOM的变化影响了元素的几何属性（宽、高、位置等），浏览器需要重新计算元素的几何属性，其他元素的几何属性和位置也会因此受到影响。浏览器会使渲染树中受到影响的部分失效，并重新构造渲染树。这个过程称为重排。

重绘（Repaint）：当元素的外观发生变化，但没有影响布局，浏览器会将元素的新外观绘制到屏幕上。这个过程称为重绘。

重排的成本比重绘高得多，因此我们应该尽量减少重排操作。

以下操作会触发重排：

1. 添加或删除可见的DOM元素
2. 元素位置改变
3. 元素尺寸改变（包括外边距、内边距、边框厚度、宽度、高度等属性改变）
4. 内容改变（如文本改变或图片被另一个不同尺寸的图片替代）
5. 页面渲染器初始化
6. 浏览器窗口尺寸改变

如何减少DOM操作提升性能
  2. // 不好的做法：多次修改样式，触发多次重排
  3. element.style.width = '100px';
  4. element.style.height = '100px';
  5. element.style.backgroundColor = 'red';
  7. // 好的做法：一次性修改样式，只触发一次重排
  8. element.style.cssText = 'width: 100px; height: 100px; background-color: red;';
  10. // 或者使用class
  11. element.className = 'new-class';
复制代码
  2. // 不好的做法：直接操作可见DOM
  3. const list = document.getElementById('list');
  4. for (let i = 0; i < 1000; i++) {
  5.     const item = document.createElement('li');
  6.     item.textContent = `Item ${i}`;
  7.     list.appendChild(item);
  8. }
  10. // 好的做法：先克隆节点，操作后再替换
  11. const list = document.getElementById('list');
  12. const clone = list.cloneNode(false); // 浅克隆，不包含子节点
  14. for (let i = 0; i < 1000; i++) {
  15.     const item = document.createElement('li');
  16.     item.textContent = `Item ${i}`;
  17.     clone.appendChild(item);
  18. }
  20. list.parentNode.replaceChild(clone, list);
复制代码

虚拟DOM是现代前端框架（如React、Vue）广泛使用的技术，它通过在内存中维护一个虚拟的DOM树，计算出最小的DOM操作，然后批量应用到真实DOM上，从而提升性能。
  2. // 简化的虚拟DOM示例
  3. function createVirtualDOM(tag, props, children) {
  4.     return { tag, props, children };
  5. }
  7. function render(vdom, container) {
  8.     const element = document.createElement(vdom.tag);
  9.    
  10.     // 设置属性
  11.     if (vdom.props) {
  12.         for (let key in vdom.props) {
  13.             if (vdom.props.hasOwnProperty(key)) {
  14.                 element.setAttribute(key, vdom.props[key]);
  15.             }
  16.         }
  17.     }
  18.    
  19.     // 添加子元素
  20.     if (vdom.children) {
  21.         vdom.children.forEach(child => {
  22.             if (typeof child === 'string') {
  23.                 element.appendChild(document.createTextNode(child));
  24.             } else {
  25.                 render(child, element);
  26.             }
  27.         });
  28.     }
  29.    
  30.     container.appendChild(element);
  31. }
  33. // 使用虚拟DOM
  34. const vdom = createVirtualDOM('div', { class: 'container' }, [
  35.     createVirtualDOM('h1', {}, ['Hello Virtual DOM']),
  36.     createVirtualDOM('p', {}, ['This is a paragraph.'])
  37. ]);
  39. render(vdom, document.body);
复制代码

最佳实践

1. 减少DOM访问次数：缓存DOM引用，避免重复查询。
2. 批量操作DOM：使用文档片段（DocumentFragment）或离线节点进行批量操作。
3. 避免频繁读取布局信息：读取布局信息（如offsetWidth、offsetHeight等）会强制浏览器刷新布局队列，触发重排。

减少DOM访问次数：缓存DOM引用，避免重复查询。

批量操作DOM：使用文档片段（DocumentFragment）或离线节点进行批量操作。

避免频繁读取布局信息：读取布局信息（如offsetWidth、offsetHeight等）会强制浏览器刷新布局队列，触发重排。
  2. // 不好的做法：在循环中读取布局信息
  3. for (let i = 0; i < elements.length; i++) {
  4.     elements[i].style.width = elements[i].offsetWidth + 10 + 'px';
  5. }
  7. // 好的做法：先读取所有布局信息，再进行修改
  8. const widths = Array.from(elements).map(el => el.offsetWidth);
  9. for (let i = 0; i < elements.length; i++) {
  10.     elements[i].style.width = widths[i] + 10 + 'px';
  11. }
复制代码

1. 使用事件委托：减少事件监听器的数量，提升性能。
  2. // 不好的做法：为每个按钮添加事件监听器
  3. const buttons = document.querySelectorAll('.button');
  4. buttons.forEach(button => {
  5.     button.addEventListener('click', () => {
  6.         // 处理点击事件
  7.     });
  8. });
  10. // 好的做法：使用事件委托
  11. document.addEventListener('click', (event) => {
  12.     if (event.target.classList.contains('button')) {
  13.         // 处理点击事件
  14.     }
  15. });
复制代码

1. 使用CSS动画代替JavaScript动画：CSS动画通常比JavaScript动画性能更好，因为它们可以由浏览器直接优化。
  2. /* CSS动画 */
  3. .element {
  4.     transition: transform 0.3s ease;
  5. }
  7. .element:hover {
  8.     transform: scale(1.1);
  9. }
复制代码
  2. // JavaScript动画（性能较差）
  3. element.addEventListener('mouseenter', () => {
  4.     let scale = 1;
  5.     const animate = () => {
  6.         scale += 0.01;
  7.         element.style.transform = `scale(${scale})`;
  8.         if (scale < 1.1) {
  9.             requestAnimationFrame(animate);
  10.         }
  11.     };
  12.     animate();
  13. });
复制代码

实战案例：使用DOM属性构建交互式网页

让我们通过一个完整的示例来应用我们学到的DOM属性访问技巧。我们将构建一个简单的任务管理应用，包含添加、删除、标记完成和筛选任务的功能。
  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.         * {
  10.             box-sizing: border-box;
  11.             margin: 0;
  12.             padding: 0;
  13.         }
  14.         
  15.         body {
  16.             font-family: 'Arial', sans-serif;
  17.             line-height: 1.6;
  18.             color: #333;
  19.             max-width: 600px;
  20.             margin: 0 auto;
  21.             padding: 20px;
  22.         }
  23.         
  24.         h1 {
  25.             text-align: center;
  26.             margin-bottom: 20px;
  27.         }
  28.         
  29.         .task-form {
  30.             display: flex;
  31.             margin-bottom: 20px;
  32.         }
  33.         
  34.         .task-input {
  35.             flex: 1;
  36.             padding: 10px;
  37.             border: 1px solid #ddd;
  38.             border-radius: 4px 0 0 4px;
  39.             font-size: 16px;
  40.         }
  41.         
  42.         .task-submit {
  43.             padding: 10px 15px;
  44.             background: #5c67f2;
  45.             color: white;
  46.             border: none;
  47.             border-radius: 0 4px 4px 0;
  48.             cursor: pointer;
  49.             font-size: 16px;
  50.         }
  51.         
  52.         .task-submit:hover {
  53.             background: #4a54e1;
  54.         }
  55.         
  56.         .filters {
  57.             display: flex;
  58.             margin-bottom: 20px;
  59.             border-bottom: 1px solid #ddd;
  60.         }
  61.         
  62.         .filter {
  63.             padding: 10px 15px;
  64.             cursor: pointer;
  65.             border-bottom: 2px solid transparent;
  66.         }
  67.         
  68.         .filter.active {
  69.             border-bottom: 2px solid #5c67f2;
  70.             color: #5c67f2;
  71.         }
  72.         
  73.         .task-list {
  74.             list-style: none;
  75.         }
  76.         
  77.         .task-item {
  78.             display: flex;
  79.             align-items: center;
  80.             padding: 10px;
  81.             border-bottom: 1px solid #eee;
  82.         }
  83.         
  84.         .task-checkbox {
  85.             margin-right: 10px;
  86.         }
  87.         
  88.         .task-text {
  89.             flex: 1;
  90.         }
  91.         
  92.         .task-text.completed {
  93.             text-decoration: line-through;
  94.             color: #999;
  95.         }
  96.         
  97.         .task-delete {
  98.             background: #ff5252;
  99.             color: white;
  100.             border: none;
  101.             padding: 5px 10px;
  102.             border-radius: 4px;
  103.             cursor: pointer;
  104.         }
  105.         
  106.         .task-delete:hover {
  107.             background: #ff3838;
  108.         }
  109.         
  110.         .task-count {
  111.             text-align: center;
  112.             margin-top: 20px;
  113.             color: #999;
  114.         }
  115.     </style>
  116. </head>
  117. <body>
  118.     <h1>任务管理应用</h1>
  119.    
  120.     <form class="task-form" id="taskForm">
  121.         <input type="text" class="task-input" id="taskInput" placeholder="添加新任务..." required>
  122.         <button type="submit" class="task-submit">添加</button>
  123.     </form>
  124.    
  125.     <div class="filters">
  126.         <div class="filter active" data-filter="all">全部</div>
  127.         <div class="filter" data-filter="active">进行中</div>
  128.         <div class="filter" data-filter="completed">已完成</div>
  129.     </div>
  130.    
  131.     <ul class="task-list" id="taskList"></ul>
  132.    
  133.     <div class="task-count" id="taskCount">0 个任务</div>
  134.    
  135.     <script>
  136.         // 使用立即执行函数表达式(IIFE)避免全局变量污染
  137.         (function() {
  138.             // DOM缓存
  139.             const taskForm = document.getElementById('taskForm');
  140.             const taskInput = document.getElementById('taskInput');
  141.             const taskList = document.getElementById('taskList');
  142.             const taskCount = document.getElementById('taskCount');
  143.             const filters = document.querySelectorAll('.filter');
  144.             
  145.             // 应用状态
  146.             let tasks = [];
  147.             let currentFilter = 'all';
  148.             
  149.             // 初始化
  150.             function init() {
  151.                 // 从本地存储加载任务
  152.                 const savedTasks = localStorage.getItem('tasks');
  153.                 if (savedTasks) {
  154.                     tasks = JSON.parse(savedTasks);
  155.                     renderTasks();
  156.                 }
  157.                
  158.                 // 事件监听
  159.                 taskForm.addEventListener('submit', handleAddTask);
  160.                
  161.                 // 使用事件委托处理筛选器点击
  162.                 document.addEventListener('click', (event) => {
  163.                     if (event.target.classList.contains('filter')) {
  164.                         handleFilterChange(event.target.dataset.filter);
  165.                     }
  166.                 });
  167.                
  168.                 // 使用事件委托处理任务列表中的点击事件
  169.                 taskList.addEventListener('click', handleTaskClick);
  170.             }
  171.             
  172.             // 添加任务
  173.             function handleAddTask(event) {
  174.                 event.preventDefault();
  175.                
  176.                 const taskText = taskInput.value.trim();
  177.                 if (taskText) {
  178.                     // 创建新任务
  179.                     const newTask = {
  180.                         id: Date.now(),
  181.                         text: taskText,
  182.                         completed: false
  183.                     };
  184.                     
  185.                     // 添加到任务数组
  186.                     tasks.push(newTask);
  187.                     
  188.                     // 保存到本地存储
  189.                     saveTasks();
  190.                     
  191.                     // 重新渲染任务列表
  192.                     renderTasks();
  193.                     
  194.                     // 清空输入框
  195.                     taskInput.value = '';
  196.                     taskInput.focus();
  197.                 }
  198.             }
  199.             
  200.             // 处理任务点击事件
  201.             function handleTaskClick(event) {
  202.                 const target = event.target;
  203.                 const taskItem = target.closest('.task-item');
  204.                
  205.                 if (!taskItem) return;
  206.                
  207.                 const taskId = parseInt(taskItem.dataset.id);
  208.                
  209.                 // 处理复选框点击
  210.                 if (target.classList.contains('task-checkbox')) {
  211.                     toggleTaskStatus(taskId);
  212.                 }
  213.                
  214.                 // 处理删除按钮点击
  215.                 if (target.classList.contains('task-delete')) {
  216.                     deleteTask(taskId);
  217.                 }
  218.             }
  219.             
  220.             // 切换任务状态
  221.             function toggleTaskStatus(taskId) {
  222.                 const task = tasks.find(t => t.id === taskId);
  223.                 if (task) {
  224.                     task.completed = !task.completed;
  225.                     saveTasks();
  226.                     renderTasks();
  227.                 }
  228.             }
  229.             
  230.             // 删除任务
  231.             function deleteTask(taskId) {
  232.                 tasks = tasks.filter(t => t.id !== taskId);
  233.                 saveTasks();
  234.                 renderTasks();
  235.             }
  236.             
  237.             // 处理筛选器变化
  238.             function handleFilterChange(filter) {
  239.                 currentFilter = filter;
  240.                
  241.                 // 更新筛选器样式
  242.                 filters.forEach(f => {
  243.                     if (f.dataset.filter === filter) {
  244.                         f.classList.add('active');
  245.                     } else {
  246.                         f.classList.remove('active');
  247.                     }
  248.                 });
  249.                
  250.                 renderTasks();
  251.             }
  252.             
  253.             // 渲染任务列表
  254.             function renderTasks() {
  255.                 // 使用文档片段批量操作DOM
  256.                 const fragment = document.createDocumentFragment();
  257.                
  258.                 // 根据当前筛选器过滤任务
  259.                 const filteredTasks = tasks.filter(task => {
  260.                     if (currentFilter === 'all') return true;
  261.                     if (currentFilter === 'active') return !task.completed;
  262.                     if (currentFilter === 'completed') return task.completed;
  263.                 });
  264.                
  265.                 // 如果没有任务，显示提示信息
  266.                 if (filteredTasks.length === 0) {
  267.                     const emptyMessage = document.createElement('li');
  268.                     emptyMessage.textContent = currentFilter === 'all'
  269.                         ? '还没有任务，添加一个吧！'
  270.                         : `没有${currentFilter === 'active' ? '进行中' : '已完成'}的任务`;
  271.                     emptyMessage.style.textAlign = 'center';
  272.                     emptyMessage.style.padding = '20px';
  273.                     emptyMessage.style.color = '#999';
  274.                     fragment.appendChild(emptyMessage);
  275.                 } else {
  276.                     // 创建任务项
  277.                     filteredTasks.forEach(task => {
  278.                         const taskItem = document.createElement('li');
  279.                         taskItem.className = 'task-item';
  280.                         taskItem.dataset.id = task.id;
  281.                         
  282.                         // 复选框
  283.                         const checkbox = document.createElement('input');
  284.                         checkbox.type = 'checkbox';
  285.                         checkbox.className = 'task-checkbox';
  286.                         checkbox.checked = task.completed;
  287.                         
  288.                         // 任务文本
  289.                         const taskText = document.createElement('span');
  290.                         taskText.className = 'task-text';
  291.                         if (task.completed) {
  292.                             taskText.classList.add('completed');
  293.                         }
  294.                         taskText.textContent = task.text;
  295.                         
  296.                         // 删除按钮
  297.                         const deleteButton = document.createElement('button');
  298.                         deleteButton.className = 'task-delete';
  299.                         deleteButton.textContent = '删除';
  300.                         
  301.                         // 添加到任务项
  302.                         taskItem.appendChild(checkbox);
  303.                         taskItem.appendChild(taskText);
  304.                         taskItem.appendChild(deleteButton);
  305.                         
  306.                         // 添加到文档片段
  307.                         fragment.appendChild(taskItem);
  308.                     });
  309.                 }
  310.                
  311.                 // 清空任务列表并添加新内容
  312.                 while (taskList.firstChild) {
  313.                     taskList.removeChild(taskList.firstChild);
  314.                 }
  315.                 taskList.appendChild(fragment);
  316.                
  317.                 // 更新任务计数
  318.                 updateTaskCount();
  319.             }
  320.             
  321.             // 更新任务计数
  322.             function updateTaskCount() {
  323.                 const activeTasks = tasks.filter(t => !t.completed).length;
  324.                 taskCount.textContent = `${activeTasks} 个任务待完成`;
  325.             }
  326.             
  327.             // 保存任务到本地存储
  328.             function saveTasks() {
  329.                 localStorage.setItem('tasks', JSON.stringify(tasks));
  330.             }
  331.             
  332.             // 初始化应用
  333.             init();
  334.         })();
  335.     </script>
  336. </body>
  337. </html>
复制代码

这个任务管理应用展示了多种DOM属性访问和操作的技巧：

1. DOM缓存：我们缓存了常用的DOM引用，避免重复查询。
2. 事件委托：我们使用事件委托处理筛选器和任务列表的点击事件，减少事件监听器的数量。
3. 批量DOM操作：使用文档片段（DocumentFragment）批量添加任务项，减少重排次数。
4. 自定义数据属性：使用data-id存储任务ID，方便在事件处理中识别任务。
5. 本地存储：使用localStorage保存任务数据，实现数据持久化。
6. 状态管理：使用JavaScript对象管理应用状态，通过渲染函数更新UI。

总结与展望

本文从基础到进阶，全面解析了HTML DOM属性的获取与修改方法，并探讨了如何通过优化DOM操作提升网页交互性能。我们学习了：

1. DOM基础概念和节点类型
2. 直接属性访问和getAttribute()/setAttribute()方法
3. 属性（Property）与属性（Attribute）的区别
4. 批量属性操作和性能优化技巧
5. 自定义属性（data-*）的使用
6. 重排与重绘的概念及其对性能的影响
7. 减少DOM操作的最佳实践

掌握这些技巧，将帮助你构建更加高效、响应迅速的网页应用。随着前端技术的不断发展，新的DOM操作方法和优化策略也在不断涌现。例如，现代前端框架（如React、Vue）通过虚拟DOM技术进一步优化了DOM操作，提供了更高级的抽象和更好的性能。

作为前端开发者，持续学习和实践这些技术，将使你能够构建出用户体验更好、性能更优的网页应用，真正成为前端开发高手。
扮演着
「七転び八起き（ななころびやおき）」
回复

使用道具 举报

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

本版积分规则