# Searching: getElement*, querySelector* DOM navigation properties are great when elements are close to each other. What if they are not? How to get an arbitrary element of the page? There are additional searching methods for that. ## document.getElementById or just id If an element has the `id` attribute, then there's a global variable by the name from that `id`. We can use it to immediately access the element no matter where it is: ```html run
Element
``` The behavior is described [in the specification](http://www.whatwg.org/specs/web-apps/current-work/#dom-window-nameditem), but it is supported mainly for compatibility. The browser tries to help us by mixing namespaces of JS and DOM. Good for very simple scripts, but there may be name conflicts. Also, when we look in JS and don't have HTML in view, it's not obvious where the variable comes from. If we declare a variable with the same name, it takes precedence: ```html run untrusted height=0
``` The better alternative is to use a special method `document.getElementById(id)`. For instance: ```html run
Element
``` Here in the tutorial we'll often use `id` to directly reference an element, but that's only to keep things short. In real life `document.getElementById` is the preferred method. ```smart header="There can be only one" The `id` must be unique. There can be only one element in the document with the given `id`. If there are multiple elements with the same `id`, then the behavior of corresponding methods is unpredictable. The browser may return any of them at random. So please stick to the rule and keep `id` unique. ``` ```warn header="Only `document.getElementById`, not `anyNode.getElementById`" The method `getElementById` that can be called only on `document` object. It looks for the given `id` in the whole document. ``` ## querySelectorAll [#querySelectorAll] By far, the most versatile method, `elem.querySelectorAll(css)` returns all elements inside `elem` matching the given CSS selector. Here we look for all `
  • ` elements that are last children: ```html run ``` This method is indeed powerful, because any CSS selector can be used. ```smart header="Can use pseudo-classes as well" Pseudo-classes in the CSS selector like `:hover` and `:active` are also supported. For instance, `document.querySelectorAll(':hover')` will return the collection with elements that the pointer is over now (in nesting order: from the outermost `` to the most nested one). ``` ## querySelector [#querySelector] The call to `elem.querySelector(css)` returns the first element for the given CSS selector. In other words, the result is the same as `elem.querySelectorAll(css)[0]`, but the latter is looking for *all* elements and picking one, while `elem.querySelector` just looks for one. So it's faster and also shorter to write. ## matches Previous methods were searching the DOM. The [elem.matches(css)](http://dom.spec.whatwg.org/#dom-element-matches) does not look for anything, it merely checks if `elem` matches the given CSS-selector. It returns `true` or `false`. The method comes in handy when we are iterating over elements (like in array or something) and trying to filter those that interest us. For instance: ```html run ... ... ``` ## closest *Ancestors* of an element are: parent, the parent of parent, its parent and so on. The ancestors together form the chain of parents from the element to the top. The method `elem.closest(css)` looks the nearest ancestor that matches the CSS-selector. The `elem` itself is also included in the search. In other words, the method `closest` goes up from the element and checks each of parents. If it matches the selector, then the search stops, and the ancestor is returned. For instance: ```html run

    Contents

    ``` ## getElementsBy* There are also other methods to look for nodes by a tag, class, etc. Today, they are mostly history, as `querySelector` is more powerful and shorter to write. So here we cover them mainly for completeness, while you can still find them in the old scripts. - `elem.getElementsByTagName(tag)` looks for elements with the given tag and returns the collection of them. The `tag` parameter can also be a star `"*"` for "any tags". - `elem.getElementsByClassName(className)` returns elements that have the given CSS class. - `document.getElementsByName(name)` returns elements with the given `name` attribute, document-wide. very rarely used. For instance: ```js // get all divs in the document let divs = document.getElementsByTagName('div'); ``` Let's find all `input` tags inside the table: ```html run height=50
    Your age:
    ``` ```warn header="Don't forget the `\"s\"` letter!" Novice developers sometimes forget the letter `"s"`. That is, they try to call `getElementByTagName` instead of getElementsByTagName. The `"s"` letter is absent in `getElementById`, because it returns a single element. But `getElementsByTagName` returns a collection of elements, so there's `"s"` inside. ``` ````warn header="It returns a collection, not an element!" Another widespread novice mistake is to write: ```js // doesn't work document.getElementsByTagName('input').value = 5; ``` That won't work, because it takes a *collection* of inputs and assigns the value to it rather than to elements inside it. We should either iterate over the collection or get an element by its index, and then assign, like this: ```js // should work (if there's an input) document.getElementsByTagName('input')[0].value = 5; ``` ```` Looking for `.article` elements: ```html run height=50
    Article
    Long article
    ``` ## Live collections All methods `"getElementsBy*"` return a *live* collection. Such collections always reflect the current state of the document and "auto-update" when it changes. In the example below, there are two scripts. 1. The first one creates a reference to the collection of `
    `. As of now, its length is `1`. 2. The second scripts runs after the browser meets one more `
    `, so its length is `2`. ```html run
    First div
    Second div
    ``` In contrast, `querySelectorAll` returns a *static* collection. It's like a fixed array of elements. If we use it instead, then both scripts output `1`: ```html run
    First div
    Second div
    ``` Now we can easily see the difference. The static collection did not increase after the appearance of a new `div` in the document. ## Summary There are 6 main methods to search for nodes in DOM:
    Method Searches by... Can call on an element? Live?
    querySelector CSS-selector ✔ -
    querySelectorAll CSS-selector ✔ -
    getElementById id - -
    getElementsByName name - ✔
    getElementsByTagName tag or '*' ✔ ✔
    getElementsByClassName class ✔ ✔
    By far the most used are `querySelector` and `querySelectorAll`, but `getElementBy*` can be sporadically helpful or found in the old scripts. Besides that: - There is `elem.matches(css)` to check if `elem` matches the given CSS selector. - There is `elem.closest(css)` to look for the nearest ancestor that matches the given CSS-selector. The `elem` itself is also checked. And let's mention one more method here to check for the child-parent relationship, as it's sometimes useful: - `elemA.contains(elemB)` returns true if `elemB` is inside `elemA` (a descendant of `elemA`) or when `elemA==elemB`.