当元素彼此靠得近时，DOM 导航属性（navigation property）非常有用。如果不是，那该怎么办？如何去获取页面上的任意元素？

还有其他搜索方法。

document.getElementById 或者只使用 id

如果一个元素有 id 特性（attribute），那我们就可以使用 document.getElementById(id) 方法获取该元素，无论它在哪里。

例如：

  1. <div id="elem">
  2.   <div id="elem-content">Element</div>
  3. </div>
  5. <script>
  6.   // 获取该元素
  7.   let elem = document.getElementById('elem');
  9.   // 将该元素背景改为红色
  10.   elem.style.background = 'red';
  11. </script>

此外，还有一个通过 id 命名的全局变量，它引用了元素：

  1. <div id="elem">
  2.   <div id="elem-content">Element</div>
  3. </div>
  5. <script>
  6.   // elem 是对带有 id="elem" 的 DOM 元素的引用
  7.   elem.style.background = 'red';
  9.   // id="elem-content" 内有连字符，所以它不能成为一个变量
  10.   // ...但是我们可以通过使用方括号 window['elem-content'] 来访问它
  11. </script>

……除非我们声明一个具有相同名称的 JavaScript 变量，否则它具有优先权：

  1. <div id="elem"></div>
  3. <script>
  4.   let elem = 5; // 现在 elem 是 5，而不是对 <div id="elem"> 的引用
  6.   alert(elem); // 5
  7. </script>

请不要使用以 id 命名的全局变量来访问元素

在规范中 对此行为进行了描述，所以它是一种标准。但这是注意考虑到兼容性才支持的。

浏览器尝试通过混合 JavaScript 和 DOM 的命名空间来帮助我们。对于内联到 HTML 中的简单脚本来说，这还行，但是通常来说，这不是一件好事。因为这可能会造成命名冲突。另外，当人们阅读 JavaScript 代码且看不到对应的 HTML 时，变量的来源就会不明显。

在本教程中，我们只会在元素来源非常明显时，为了简洁起见，才会使用 id 直接引用对应的元素。

在实际开发中，document.getElementById 是首选方法。

id 必须是唯一的

id 必须是唯一的。在文档中，只能有一个元素带有给定的 id。

如果有多个元素都带有同一个 id，那么使用它的方法的行为是不可预测的，例如 document.getElementById 可能会随机返回其中一个元素。因此，请遵守规则，保持 id 的唯一性。

只有 document.getElementById，没有 anyElem.getElementById

getElementById 方法只能被在 document 对象上调用。它会在整个文档中查找给定的 id。

querySelectorAll

到目前为止，最通用的方法是 elem.querySelectorAll(css)，它返回 elem 中与给定 CSS 选择器匹配的所有元素。

在这里，我们查找所有为最后一个子元素的 <li> 元素：

  1. <ul>
  2.   <li>The</li>
  3.   <li>test</li>
  4. </ul>
  5. <ul>
  6.   <li>has</li>
  7.   <li>passed</li>
  8. </ul>
  9. <script>
  10.   let elements = document.querySelectorAll('ul > li:last-child');
  12.   for (let elem of elements) {
  13.     alert(elem.innerHTML); // "test", "passed"
  14.   }
  15. </script>

这个方法确实功能强大，因为可以使用任何 CSS 选择器。

也可以使用伪类

CSS 选择器的伪类，例如 :hover 和 :active 也都是被支持的。例如，document.querySelectorAll(':hover') 将会返回鼠标指针现在已经结束的元素的集合（按嵌套顺序：从最外层 <html> 到嵌套最多的元素）。

querySelector

elem.querySelector(css) 调用会返回给定 CSS 选择器的第一个元素。

换句话说，结果与 elem.querySelectorAll(css)[0] 相同，但是后者会查找 所有 元素，并从中选取一个，而 elem.querySelector 只会查找一个。因此它在速度上更快，并且写起来更短。

matches

之前的方法是搜索 DOM。

elem.matches(css) 不会查找任何内容，它只会检查 elem 是否与给定的 CSS 选择器匹配。它返回 true 或 false。

当我们遍历元素（例如数组或其他内容）并试图过滤那些我们感兴趣的元素时，这个方法会很有用。

例如：

  1. <a href="http://example.com/file.zip">...</a>
  2. <a href="http://ya.ru">...</a>
  4. <script>
  5.   // 不一定是 document.body.children，还可以是任何集合
  6.   for (let elem of document.body.children) {
  7.     if (elem.matches('a[href$="zip"]')) {
  8.       alert("The archive reference: " + elem.href );
  9.     }
  10.   }
  11. </script>

closest

元素的祖先（ancestor）是：父级，父级的父级，它的父级等。祖先们一起组成了从元素到顶端的父级链。

elem.closest(css) 方法会查找与 CSS 选择器匹配的最近的祖先。elem 自己也会被搜索。

换句话说，方法 closest 在元素中得到了提升，并检查每个父级。如果它与选择器匹配，则停止搜索并返回该祖先。

例如：

  1. <h1>Contents</h1>
  3. <div class="contents">
  4.   <ul class="book">
  5.     <li class="chapter">Chapter 1</li>
  6.     <li class="chapter">Chapter 1</li>
  7.   </ul>
  8. </div>
  10. <script>
  11.   let chapter = document.querySelector('.chapter'); // LI
  13.   alert(chapter.closest('.book')); // UL
  14.   alert(chapter.closest('.contents')); // DIV
  16.   alert(chapter.closest('h1')); // null（因为 h1 不是祖先）
  17. </script>

getElementsBy*

还有其他通过标签，类等查找节点的方法。

如今，它们大多已经成为了历史，因为 querySelector 功能更强大，写起来更短。

因此，这里我们介绍它们只是为了完整起见，而你仍然可以在就脚本中找到这些方法。

  • elem.getElementsByTagName(tag) 查找具有给定标签的元素，并返回它们的集合。tag 参数也可以是对于“任何标签”的星号 "*"。
  • elem.getElementsByClassName(className) 返回具有给定CSS类的元素。
  • document.getElementsByName(name) 返回在文档范围内具有给定 name 特性的元素。很少使用。

例如：

  1. // 获取文档中的所有 div
  2. let divs = document.getElementsByTagName('div');

让我们查找 table 中的所有 input 标签：

  1. <table id="table">
  2.   <tr>
  3.     <td>Your age:</td>
  5.     <td>
  6.       <label>
  7.         <input type="radio" name="age" value="young" checked> less than 18
  8.       </label>
  9.       <label>
  10.         <input type="radio" name="age" value="mature"> from 18 to 50
  11.       </label>
  12.       <label>
  13.         <input type="radio" name="age" value="senior"> more than 60
  14.       </label>
  15.     </td>
  16.   </tr>
  17. </table>
  19. <script>
  20.   let inputs = table.getElementsByTagName('input');
  22.   for (let input of inputs) {
  23.     alert( input.value + ': ' + input.checked );
  24.   }
  25. </script>

不要忘记字母 "s"！

新手开发者有时会忘记字符 "s"。也就是说，他们会调用 getElementByTagName 而不是 getElement**s**ByTagName。

getElementById 中没有字母 "s"，是因为它只返回单个元素。但是 getElementsByTagName 返回的是元素的集合，所以里面有 "s"。

它返回的是一个集合，不是一个元素！

新手的另一个普遍的错误是写：

  1. // 行不通
  2. document.getElementsByTagName('input').value = 5;

这是行不通的，因为它需要的是一个 input 的 集合，并将值赋（assign）给它，而不是赋值给其中的一个元素。

我们应该遍历集合或通过对应的索引来获取元素，然后赋值，如下所示：

  1. // 应该可以运行（如果有 input）
  2. document.getElementsByTagName('input')[0].value = 5;

查找 .article 元素：

  1. <form name="my-form">
  2.   <div class="article">Article</div>
  3.   <div class="long article">Long article</div>
  4. </form>
  6. <script>
  7.   // 按 name 特性查找
  8.   let form = document.getElementsByName('my-form')[0];
  10.   // 在 form 中按 class 查找
  11.   let articles = form.getElementsByClassName('article');
  12.   alert(articles.length); // 2, found two elements with class "article"
  13. </script>

实时的集合

所有的 "getElementsBy*" 方法都会返回一个 实时的（live） 集合。这样的集合始终反映的是文档的当前状态，并且在文档发生更改时会“自动更新”。

在下面的例子中，有两个脚本。

  1. 第一个创建了对 <div> 的集合的引用。截至目前，它的长度是 1。
  2. 第二个脚本在浏览器再遇到一个 <div> 时运行，所以它的长度是 2。
  1. <div>First div</div>
  3. <script>
  4.   let divs = document.getElementsByTagName('div');
  5.   alert(divs.length); // 1
  6. </script>
  8. <div>Second div</div>
  10. <script>
  11.   alert(divs.length); // 2
  12. </script>

相反，querySelectorAll 返回的是一个 静态的 集合。就像元素的固定数组。

如果我们使用它，那么两个脚本都会输出 1：

  1. <div>First div</div>
  3. <script>
  4.   let divs = document.querySelectorAll('div');
  5.   alert(divs.length); // 1
  6. </script>
  8. <div>Second div</div>
  10. <script>
  11.   alert(divs.length); // 1
  12. </script>

现在我们可以很容易地看到不同之处。在文档中出现新的 div 后，静态集合并没有增加。

总结

有 6 种主要的方法，可以在 DOM 中搜素节点：

MethodSearches by…Can call on an element?Live?
querySelectorCSS-selector✔-
querySelectorAllCSS-selector✔-
getElementByIdid--
getElementsByNamename-✔
getElementsByTagNametag or ‘*’✔✔
getElementsByClassNameclass✔✔

目前为止，最常用的是 querySelector 和 querySelectorAll，但是 getElementBy* 可能会偶尔有用，或者可以在就脚本中找到。

此外：

  • elem.matches(css) 用于检查 elem 与给定的 CSS 选择器是否匹配。
  • elem.closest(css) 用于查找与给定 CSS 选择器相匹配的最近的祖先。elem 本身也会被检查。

让我们在这里提一下另一种用来检查子级与父级之间关系的方法，因为它有时很有用：

  • 如果 elemB 在 elemA 内（elemA 的后代）或者 elemA==elemB，elemA.contains(elemB) 将返回 true。

任务

搜索元素

重要程度: 4

这是带有表格（table）和表单（form）的文档。

如何查找？……

  1. 带有 id="age-table" 的表格。
  2. 表格内的所有 label 元素（应该有三个）。
  3. 表格中的第一个 td（带有 “Age” 字段）。
  4. 带有 name="search" 的 form。
  5. 表单中的第一个 input。
  6. 表单中的最后一个 input。

在一个单独的窗口中打开 table.html 页面，并对此页面使用浏览器开发者工具。

解决方案

实现的方式有很多种。

以下列举的是其中一些方法：

  1. // 1. 带有 id="age-table" 的表格。
  2. let table = document.getElementById('age-table')
  4. // 2. 表格内的所有 label 元素
  5. table.getElementsByTagName('label')
  6. // 或
  7. document.querySelectorAll('#age-table label')
  9. // 3. 表格中的第一个 td（带有 "Age" 字段）
  10. table.rows[0].cells[0]
  11. // 或
  12. table.getElementsByTagName('td')[0]
  13. // 或
  14. table.querySelector('td')
  16. // 4. 带有 name="search" 的 form。
  17. // 假设文档中只有一个 name="search" 的元素
  18. let form = document.getElementsByName('search')[0]
  19. // 或者，专门对于 form
  20. document.querySelector('form[name="search"]')
  22. // 5. 表单中的第一个 input
  23. form.getElementsByTagName('input')[0]
  24. // 或
  25. form.querySelector('input')
  27. // 6. 表单中的最后一个 input
  28. let inputs = form.querySelectorAll('input') // 查找所有 input
  29. inputs[inputs.length-1] // 取出最后一个