JavaScript DOM 操作完整指南：從初學者到專業人士

1. DOM 操作簡介

   • DOM 的定義與重要性
   • JavaScript 如何與 DOM 互動
   • 常見用例概述

2. 理解 DOM 樹

   • DOM 的結構
   • 節點與元素
   • DOM樹遍歷

3. 選擇 DOM 元素

   • 基本選擇器（getElementById、getElementsByClassName、getElementsByTagName）
   • 現代選擇器（querySelector、querySelectorAll）
   • 選擇器的性能考量

4. 操縱內容

   • 修改內部 HTML 與文字內容（innerHTML、innerText、textContent）
   • 防範 XSS 攻擊
   • 使用 HTML 屬性（setAttribute、getAttribute、removeAttribute）

5. 樣式與類別

   • 更改內聯樣式
   • 使用 classList 進行動態樣式
   • CSS 類別相對於內聯樣式的優點

6. 事件處理

   • 事件監聽器基礎（addEventListener、removeEventListener）
   • 常見事件（點擊、滑鼠懸停、按鍵等）
   • 活動委託
   • 事件傳播與防止預設操作

7. 進階 DOM 操作

   • 建立和插入元素（createElement、appendChild、insertBefore）
   • 複製與刪除元素
   • 使用文件片段提高效率

8. 表單處理與驗證

   • 存取表單元素和值
   • 驗證使用者輸入
   • 處理表單提交

9. 處理複雜結構

   • 操作表格
   • 處理清單與樹狀結構
   • 動態內容產生

10. 動畫與轉場效果

    • DOM 中動畫的基本概念
    • 使用 CSS 轉場
    • JavaScript 驅動的動畫

11. 最佳實務與效能最佳化

    • 最大限度地減少回流和重繪
    • 高效處理大型 DOM
    • 使用 requestAnimationFrame 實現流暢的動畫

12. 常見陷阱與除錯

    • DOM 操作中的常見錯誤
    • 除錯技術與工具

13. 個案研究與實際例子

    • DOM 操作的真實範例
    • 建構動態 Web 元件的逐步演練

14. 未來趨勢與考量

    • 網路開發不斷發展的前景
    • React、Vue 和 Angular 等框架對 DOM 操作的影響

15. 結論

    • 關鍵概念總結
    • 掌握 DOM 操作對於現代 Web 開發的重要性

---

1. DOM操作簡介

文件物件模型 (DOM) 是 Web 開發中的基本概念，可作為 HTML 文件和 JavaScript 之間的橋樑。 DOM 將網頁的結構表示為節點的分層樹，讓開發人員以程式設計方式存取和操作頁面的內容、結構和樣式。此功能可以創建動態和互動式網路體驗，其中內容可以根據使用者操作或其他刺激即時更新。

JavaScript 作為網路語言，在 DOM 操作中扮演至關重要的角色。透過提供豐富的 API，JavaScript 允許開發人員在 DOM 上執行各種操作，從簡單的內容更新到複雜的互動功能。了解如何有效地利用這些 API 對於任何 Web 開發人員至關重要，因為它為創建更具吸引力和用戶友好的網站打開了大門。

在這份綜合指南中，我們將探索 JavaScript DOM 操作的細節，涵蓋從基本概念到高階技術的所有內容。無論您是想要了解基礎知識的初學者，還是想要提高技能的經驗豐富的開發人員，本指南都將為您提供掌握 DOM 操作所需的知識和工具。

2. 理解 DOM 樹

DOM 樹是網頁上元素的分層表示。該樹的頂部是文檔對象，它充當根節點。在文件物件下面，有各種類型的節點，包括元素節點、文字節點、註解節點等等。每個節點都代表文件的特定部分，例如 HTML 標籤、文字區塊或註解。

節點與元素

在 DOM 中，每一段內容都表示為一個節點。最常見的節點類型包括：

• 元素節點：這些是最重要的節點，代表 HTML 元素，如
  、

  、 等。每個元素節點可以有屬性、子節點和文字內容.

• 文字節點：這些節點表示元素內的文字內容。例如，在 HTML

  Hello, World!

  中，文字「Hello, World!」是段落元素節點內的文字節點。
• 屬性節點：這些節點表示元素的屬性。例如，在 Link 中，href 屬性表示為屬性節點。

DOM 樹遍歷

為了有效地操作 DOM，了解如何遍歷 DOM 樹至關重要。遍歷是指瀏覽 DOM 樹中的節點以尋找特定元素或元素群組。 JavaScript 為此目的提供了幾種方法：

• 父節點：parentNode 屬性傳回給定節點的父節點。

  const parent = childNode.parentNode;

• Child Nodes：childNodes 屬性傳回節點子節點的 NodeList。

  const children = parentNode.childNodes;

• 第一個和最後一個子節點：firstChild 和lastChild 屬性分別傳回父節點的第一個和最後一個子節點。

  const firstChild = parentNode.firstChild;
  const lastChild = parentNode.lastChild;

• Next 和 Previous Sibling：nextSibling 和 previousSibling 屬性分別傳回節點的下一個和上一個兄弟節點。

  const nextSibling = node.nextSibling;
  const previousSibling = node.previousSibling;

透過理解和利用這些屬性，開發人員可以有效地導航和操作 DOM 樹。

3. 選擇 DOM 元素

選擇元素是任何 DOM 操作任務的第一步。 JavaScript 提供了多種選擇元素的方法，每種方法都有自己的用例和優點。

基本選擇器

• getElementById：此方法透過其唯一 ID 選擇單一元素。由於 ID 在文件中是唯一的，因此該方法僅傳回一個元素。

  const element = document.getElementById('myElement');

• getElementsByClassName：此方法選擇具有給定類別名稱的所有元素並傳回 HTMLCollection。與 getElementById 不同，此方法可以傳回多個元素。

  const elements = document.getElementsByClassName('myClass');

• getElementsByTagName：此方法選擇具有給定標籤名稱（例如 div、p 或 a）的所有元素，並傳回 HTMLCollection。

  const elements = document.getElementsByTagName('p');

現代選擇器

現代 Web 開發經常使用 querySelector 和 querySelectorAll 來實現更靈活、更強大的元素選擇。

• querySelector：此方法傳回與指定 CSS 選擇器相符的第一個元素。它可用於根據 ID、類別、屬性等選擇元素。

  const element = document.querySelector('.myClass');

• querySelectorAll：此方法傳回與指定 CSS 選擇器相符的所有元素，並傳回 NodeList。與 HTMLCollections 不同，NodeLists 可以使用現代陣列方法（例如 forEach）進行迭代。

  const elements = document.querySelectorAll('.myClass');

選擇器的效能注意事項

選擇元素時，尤其是在大型文件中，效能可能會成為一個問題。使用最有效的方法來完成手邊的任務非常重要。例如，按 ID 選擇時，getElementById 通常比 querySelector 更快，因為它針對特定任務進行了最佳化。同樣，透過選擇特定父節點內的元素來限制搜尋範圍可以減少查找元素所需的時間。

4. 操縱內容

選擇要操作的元素後，您可以使用各種屬性和方法來修改其內容。

修改內部 HTML 與文字內容

• innerHTML: This property sets or returns the HTML content of an element. It's useful for dynamically updating the structure of a web page, as it can insert new elements along with text.

  element.innerHTML = '<strong>New Content</strong>';

• innerText: This property sets or returns the text content of an element, excluding any HTML tags. It's useful when you want to update the visible text without affecting the underlying structure.

  element.innerText = 'New Content';

• textContent: Similar to innerText, this property sets or returns the text content of an element. However, textContent is more consistent across different browsers and also includes hidden elements' text.

  element

.textContent = 'New Content';

Safeguards Against XSS Attacks

When using innerHTML, it's crucial to be aware of potential security risks, particularly Cross-Site Scripting (XSS) attacks. XSS occurs when an attacker injects malicious scripts into web pages, potentially compromising user data and security. To mitigate this risk, avoid using innerHTML with unsanitized user input. Instead, use safer alternatives like textContent or sanitization libraries.

Working with HTML Attributes

HTML attributes provide additional information about elements and can be manipulated using JavaScript.

• setAttribute: This method adds a new attribute or changes the value of an existing attribute.

  element.setAttribute('src', 'image.jpg');

• getAttribute: This method returns the value of an attribute.

  const src = element.getAttribute('src');

• removeAttribute: This method removes an attribute from an element.

  element.removeAttribute('src');

By manipulating attributes, developers can change the behavior and appearance of elements dynamically.

5. Styling and Classes

Styling elements dynamically is a common requirement in web development. JavaScript provides several ways to manipulate the styles and classes of elements.

Changing Inline Styles

You can change the inline styles of an element using the style property. Each CSS property can be accessed as a property of the style object, using camelCase for multi-word properties.


element.style.color = 'blue';
element.style.backgroundColor = 'yellow';

While changing inline styles can be useful for specific cases, it's generally better to use CSS classes for styling. This approach keeps your CSS and JavaScript separate, making your code more maintainable and easier to manage.

Using classList for Dynamic Styling

The classList property provides a convenient way to work with an element's class attribute. It offers methods to add, remove, toggle, and check for classes, making it a powerful tool for dynamic styling.

• Adding a Class:

  element.classList.add('newClass');

• Removing a Class:

  element.classList.remove('oldClass');

• Toggling a Class:

  element.classList.toggle('active');

• Checking for a Class:

  if (element.classList.contains('active')) {
    // Do something
  }

Using classList is generally preferable to directly manipulating the className property, as it avoids issues with overwriting existing classes and simplifies code.

Advantages of CSS Classes over Inline Styles

Using CSS classes instead of inline styles has several advantages:

1. Separation of Concerns: CSS classes separate styling from content, making it easier to maintain and update styles without touching the HTML structure.
2. Reusability: CSS classes can be reused across multiple elements, promoting consistency and reducing duplication.
3. Efficiency: Changing classes is more efficient than updating multiple inline styles, as it reduces the number of DOM updates and minimizes reflows and repaints.

6. Event Handling

Events are a core concept in web development, allowing developers to respond to user interactions, such as clicks, key presses, and form submissions. JavaScript provides a robust event handling system to manage these interactions.

Basics of Event Listeners

An event listener is a function that runs in response to a specific event on an element. The addEventListener method is used to attach event listeners to elements.


element.addEventListener('click', function() {
  alert('Element clicked!');
});

The first argument to addEventListener is the event type (e.g., 'click'), and the second argument is the callback function that runs when the event occurs.

Common Events

• Click Event: Triggered when an element is clicked.

  element.addEventListener('click', function() {
    // Handle click event
  });

• Mouse Events: Include events like mouseover, mouseout, and mousemove.

  element.addEventListener('mouseover', function() {
    // Handle mouseover event
  });

• Keyboard Events: Include events like keydown, keyup, and keypress.

  document.addEventListener('keydown', function(event) {
    console.log(`Key pressed: ${event.key}`);
  });

• Form Events: Include events like submit, change, and input.

  form.addEventListener('submit', function(event) {
    event.preventDefault(); // Prevent form submission
    // Handle form submission
  });

Event Delegation

Event delegation is a technique for handling events efficiently by leveraging event propagation. Instead of attaching event listeners to each individual child element, you attach a single event listener to a common parent element. This listener can then handle events for all child elements based on the event's target.


document.querySelector('.parent').addEventListener('click', function(event) {
  if (event.target && event.target.matches('.child')) {
    // Handle click event on child element
  }
});

Event delegation is particularly useful when dealing with dynamically added elements, as it avoids the need to attach event listeners to each new element.

Event Propagation and Preventing Default Actions

Events in the DOM propagate through three phases: the capturing phase, the target phase, and the bubbling phase. By default, event listeners are registered in the bubbling phase, but you can specify the capturing phase by passing true as the third argument to addEventListener.


element.addEventListener('click', function() {
  // Handle click event
}, true); // Use capturing phase

To stop an event from propagating, you can use the stopPropagation method.


element.addEventListener('click', function(event) {
  event.stopPropagation();
});

Additionally, to prevent the default action associated with an event (such as navigating to a link or submitting a form), use the preventDefault method.


element.addEventListener('click', function(event) {
  event.preventDefault();
  // Prevent link from navigating
});

7. Advanced DOM Manipulation

Beyond basic manipulation, JavaScript allows for more complex and advanced DOM operations, such as creating and removing elements, cloning nodes, and optimizing performance.

Creating and Inserting Elements

Creating new elements and adding them to the DOM is a common requirement in dynamic web applications. The document.createElement method creates a new element node.


const newElement = document.createElement('div');
newElement.textContent = 'Hello, World!';

Once you've created an element, you can insert it into the DOM using methods like appendChild and insertBefore.

• Appending Elements:

  document.body.appendChild(newElement);

• Inserting Before Another Element:

  const referenceElement = document.getElementById('myElement');
  document.body.insertBefore(newElement, referenceElement);

Cloning and Removing Elements

JavaScript allows you to clone existing DOM nodes, creating a copy that can be modified or inserted elsewhere.

• Cloning an Element:

  const clone = element.cloneNode(true); // true for deep clone
  document.body.appendChild(clone);

To remove elements, you can use the removeChild or remove methods.

• Removing Child Elements:

  const parent = document.getElementById('parentElement');
  const child = document.getElementById('childElement');
  parent.removeChild(child);

• Using remove Method:

  const element = document.getElementById('myElement');
  element.remove();

Working with Document Fragments for Efficiency

Document fragments are lightweight containers that can hold a portion of the DOM structure. They are not part of the live DOM tree, which means operations performed on them do not trigger reflows and repaints, making them highly efficient for batch DOM updates.


const fragment = document.createDocumentFragment();
const newElement1 = document.createElement('div');
newElement1.textContent = 'Item 1';
fragment.appendChild(newElement1);

const newElement2 = document.createElement('div');
newElement2.textContent = 'Item 2';
fragment.appendChild(newElement2);

document.body.appendChild(fragment); // Append all elements at once

Using document fragments is a best practice when adding multiple elements to the DOM, as it minimizes performance costs.

8. Form Handling and Validation

Forms are a fundamental part of web applications, enabling user input and interaction. JavaScript provides powerful tools for accessing form elements, handling their values, and validating input before submission.

Accessing Form Elements and Values

Form elements can be accessed using the same selectors as other DOM elements. Once selected, their values can be retrieved or set using the value property.


const input = document.getElementById('myInput');
const inputValue = input.value;

input.value = 'New Value'; // Set a new value

For forms with multiple elements, you can iterate through the form's elements collection.


const form = document.getElementById('myForm');
for (let i = 0; i < form.elements.length; i++) {
  console.log(form.elements[i].name, form.elements[i].value);
}

Validating User Input

Validation ensures that the data entered by users meets certain criteria before it is submitted. JavaScript can perform client-side validation, providing instant feedback to users and reducing server load.

• Basic Validation:

  const input = document.getElementById('myInput');
  if (input.value === '') {
    alert('This field is required.');
  }

• Regular Expressions: Regular expressions can be used for more complex validation, such as checking email formats or password strength.

  const email = document.getElementById('email');
  const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  if (!emailPattern.test(email.value)) {
    alert('Please enter a valid email address.');
  }

Handling Form Submissions

To handle form submissions, you can attach an event listener to the form's submit event. This allows you to prevent the default submission and perform custom actions, such as validation or AJAX submissions.


const form = document.getElementById('myForm');
form.addEventListener('submit', function(event) {
  event.preventDefault(); // Prevent default form submission

  // Custom validation and submission logic
  if (isValidForm()) {
    // Submit form data via AJAX or other means
  }
});

function isValidForm() {
  // Perform validation and return true or false
  return true;
}

9. Working with Complex Structures

Handling complex structures like tables, lists, and tree-like structures requires specific techniques and considerations. JavaScript provides a range of methods and best practices for working with these elements.

Manipulating Tables

Tables are a common way to display data in a structured format. JavaScript allows you to create, modify, and manipulate tables dynamically.

• Creating Table Elements:

  const table = document.createElement('table');
  const row = table.insertRow();
  const cell1 = row.insertCell();
  const cell2 = row.insertCell();
  cell1.textContent = 'Row 1, Cell 1';
  cell2.textContent = 'Row 1, Cell 2';
  document.body.appendChild(table);

• Adding and Removing Rows:

  const table = document.getElementById('myTable');
  const newRow = table.insertRow();
  newRow.insertCell().textContent = 'New Cell';

  table.deleteRow(0); // Delete the first row

Handling Lists and Tree Structures

Lists and tree structures are often used for navigation menus, file explorers, and hierarchical data. JavaScript allows for the creation and manipulation of these structures.

• Creating Lists:

  const list = document.createElement('ul');
  const listItem = document.createElement('li');
  listItem.textContent = 'Item 1';
  list.appendChild(listItem);
  document.body.appendChild(list);

• Manipulating List Items:

  const list = document.getElementById('myList');
  const newItem = document.createElement('li');
  newItem.textContent = 'New Item';
  list.appendChild(newItem);

  list.removeChild(list.firstChild); // Remove the first item

Dynamic Content Generation

Dynamic content generation involves creating and updating content based on user interactions or other data sources. This technique is commonly used in applications like dashboards, data visualizations, and content management systems.

• Generating Content Based on Data:

  const data = ['Item 1', 'Item 2', 'Item 3'];
  const list = document.createElement('ul');

  data.forEach(item => {
    const listItem = document.createElement('li');
    listItem.textContent = item;
    list.appendChild(listItem);
  });

  document.body.appendChild(list);

Dynamic content generation often involves working with APIs, where data is fetched from a server and displayed on the page.

10. Animation and Transition Effects

Animations and transitions add visual appeal and enhance the user experience. JavaScript, in conjunction with CSS, allows for the creation of smooth and engaging animations.

Basic Concepts of Animations in the DOM

Animations can be created using CSS animations or JavaScript. CSS animations are defined in stylesheets, while JavaScript provides more control and flexibility.

• CSS Animations:

  @keyframes fadeIn {
    from { opacity: 0; }
    to { opacity: 1; }
  }

  .fade-in {
    animation: fadeIn 2s;
  }

• JavaScript Animations:

  const element = document.getElementById('animateMe');
  let opacity = 0;

  function fadeIn() {
    opacity += 0.01;
    element.style.opacity = opacity;

    if (opacity < 1) {
      requestAnimationFrame(fadeIn);
    }
  }

  fadeIn();

Using CSS Transitions

CSS transitions allow you to change property values smoothly over a specified duration.

• Defining Transitions:

  .box {
    transition: transform 0.5s, opacity 0.5s;
  }

  .box:hover {
    transform: scale(1.2);
    opacity: 0.7;
  }

CSS transitions are easy to implement and can be triggered by pseudo-classes like :hover or by JavaScript class changes.

JavaScript-Driven Animations

JavaScript provides fine-grained control over animations, allowing for complex and interactive effects.

• Animating with setInterval:

  let position = 0;
  const element = document.getElementById('movingBox');

  setInterval(() => {
    position += 1;
    element.style.transform = `translateX(${position}px)`;
  }, 10);

• Using requestAnimationFrame:

  let position = 0;
  const element = document.getElementById('movingBox');

  function animate() {
    position += 1;
    element.style.transform = `translateX(${position}px)`;

    if (position < 300) {
      requestAnimationFrame(animate);
    }
  }

  animate();

requestAnimationFrame is preferred over setInterval for animations, as it synchronizes with the browser's refresh rate, resulting in smoother animations.

11. Best Practices and Performance Optimization

Efficient DOM manipulation is crucial for maintaining performance, especially in large and complex applications. Following best practices can help ensure that your applications run smoothly.

Minimizing Reflows and Repaints

Reflows and repaints are costly operations in the browser's rendering process. A reflow occurs when the layout of the page is recalculated, while a repaint is triggered when visual changes occur.

• Avoid Frequent DOM Manipulations: Batch DOM updates to minimize reflows. For example, use document.createDocumentFragment or temporarily hide elements while making changes.

• Use Efficient Selectors: Be mindful of the performance implications of complex selectors. Prefer getElementById over more general selectors when possible.

• Avoid Layout Thrashing: Reading and writing layout properties (like offsetWidth and offsetHeight) in quick succession can cause layout thrashing, leading to multiple reflows. Avoid this by caching values when possible.

Efficiently Handling Large DOMs

Large DOMs can slow down rendering and interactions. To optimize performance:

• Use Virtualization: For large datasets, consider using virtualization techniques to render only a portion of the DOM, loading more content as needed.

• Lazy Load Images: Defer the loading of off-screen images until they are needed, reducing the initial load time.

Using requestAnimationFrame for Smooth Animations

As mentioned earlier, requestAnimationFrame is the preferred method for creating smooth animations. It synchronizes with the display refresh rate, resulting in more efficient animations.


function animate() {
  // Animation logic
  requestAnimationFrame(animate);
}

animate();

12. Common Pitfalls and Debugging

While DOM manipulation is a powerful tool, it comes with potential pitfalls. Understanding common mistakes and knowing how to debug issues can save time and effort.

Common Mistakes in DOM Manipulation

• Overuse of innerHTML: Using innerHTML excessively can lead to security vulnerabilities (XSS attacks) and performance issues. Use it cautiously and prefer safer alternatives like textContent or classList.

• Ignoring Event Delegation: Attaching event listeners to many individual elements can lead to memory leaks and poor performance. Use event delegation to handle events more efficiently.

• Forgetting to Clean Up: When dynamically adding elements, don't forget to remove them when they're no longer needed to avoid memory leaks.

Debugging Techniques and Tools

• Browser Developer Tools: Modern browsers offer robust developer tools for inspecting the DOM, debugging JavaScript, and analyzing performance. Use these tools to inspect elements, set breakpoints, and monitor network requests.

• Console Logging: Use console.log and other console methods to output information and debug your code. For more advanced debugging, use console.dir to inspect objects and console.table to display data in a tabular format.

• Debugging DOM Events: Use the Event Listeners tab in browser developer tools to inspect attached event listeners. This helps in understanding which events are attached to which elements.

13. Case Studies and Practical Examples

To solidify your understanding of DOM manipulation, let's explore some real

-world examples and case studies.

Example 1: Interactive To-Do List

An interactive to-do list allows users to add, remove, and mark tasks as complete. This example involves dynamic content generation, event handling, and form validation.


document.getElementById('addTaskButton').addEventListener('click', function() {
  const taskInput = document.getElementById('taskInput');
  const taskText = taskInput.value;

  if (taskText) {
    const taskList = document.getElementById('taskList');
    const newTask = document.createElement('li');
    newTask.textContent = taskText;
    taskList.appendChild(newTask);

    taskInput.value = ''; // Clear the input field
  }
});

Example 2: Image Gallery with Lightbox Effect

An image gallery with a lightbox effect allows users to click on thumbnails to view larger images. This example demonstrates event delegation and CSS transitions.


document.getElementById('gallery').addEventListener('click', function(event) {
  if (event.target.tagName === 'IMG') {
    const src = event.target.getAttribute('data-fullsize');
    const lightbox = document.getElementById('lightbox');
    lightbox.querySelector('img').src = src;
    lightbox.style.display = 'block';
  }
});

document.getElementById('lightbox').addEventListener('click', function() {
  this.style.display = 'none';
});

Example 3: Dynamic Data Visualization

A dynamic data visualization, such as a chart or graph, updates based on user input or data changes. This example involves dynamic content generation and efficient DOM manipulation.


function updateChart(data) {
  const chart = document.getElementById('chart');
  chart.innerHTML = ''; // Clear existing chart

  data.forEach(point => {
    const bar = document.createElement('div');
    bar.className = 'bar';
    bar.style.height = `${point.value}px`;
    chart.appendChild(bar);
  });
}

const data = [{ value: 30 }, { value: 50 }, { value: 80 }];
updateChart(data);

14. Summary and Best Practices

In this comprehensive guide, we've explored the essential aspects of DOM manipulation with JavaScript, from basic concepts to advanced techniques. Here are some key takeaways:

• Understanding the DOM: The DOM represents the structure of a web page, allowing JavaScript to interact with and manipulate elements.

• Selecting and Manipulating Elements: Use efficient selectors and methods like textContent and classList for safe and efficient manipulation.

• Event Handling: Attach event listeners using addEventListener, leverage event delegation for efficiency, and understand event propagation.

• Form Handling and Validation: Access form elements, validate input, and handle form submissions to enhance user interaction and data integrity.

• Advanced Techniques: Use document fragments for efficient DOM updates, handle complex structures like tables and lists, and create smooth animations with requestAnimationFrame.

• Performance Optimization: Minimize reflows and repaints, handle large DOMs efficiently, and follow best practices to ensure optimal performance.

• Common Pitfalls and Debugging: Avoid common mistakes, use browser developer tools for debugging, and implement best practices to maintain code quality.

By mastering these concepts and techniques, you'll be well-equipped to create dynamic, interactive, and performant web applications. Keep experimenting, learning, and building to refine your skills in DOM manipulation.

15. Further Resources

To continue your journey in DOM manipulation and web development, consider exploring the following resources:

• MDN Web 文件：有關 Web 技術的綜合文件和教程，包括 DOM、JavaScript 等。
• JavaScript 資訊：現代 JavaScript 的詳細指南，涵蓋核心概念、最佳實踐和進階主題。
• 你不懂 JS：深入探討 JavaScript 核心機制的系列書籍，幫助您從基礎層面理解該語言。

編碼愉快！

---

？你可以透過捐贈來幫助我