I want to iterate over some DOM elements, I\'m doing this:
document.getElementsByClassName( \"myclass\" ).forEach( function(element, index, array) {
//do s
No. As specified in DOM4, it's an HTMLCollection (in modern browsers, at least. Older browsers returned a NodeList).
In all modern browsers (pretty much anything other IE <= 8), you can call Array's forEach
method, passing it the list of elements (be it HTMLCollection
or NodeList
) as the this
value:
var els = document.getElementsByClassName("myclass");
Array.prototype.forEach.call(els, function(el) {
// Do stuff here
console.log(el.tagName);
});
// Or
[].forEach.call(els, function (el) {...});
If you're in the happy position of being able to use ES6 (i.e. you can safely ignore Internet Explorer or you're using an ES5 transpiler), you can use Array.from:
Array.from(els).forEach((el) => {
// Do stuff here
console.log(el.tagName);
});
You can use Array.from
to convert collection to array, which is way cleaner than Array.prototype.forEach.call
:
Array.from(document.getElementsByClassName("myclass")).forEach(
function(element, index, array) {
// do stuff
}
);
In older browsers which don't support Array.from
, you need to use something like Babel.
ES6 also adds this syntax:
[...document.getElementsByClassName("myclass")].forEach(
(element, index, array) => {
// do stuff
}
);
Rest destructuring with ...
works on all array-like objects, not only arrays themselves, then good old array syntax is used to construct an array from the values.
While the alternative function querySelectorAll
(which kinda makes getElementsByClassName
obsolete) returns a collection which does have forEach
natively, other methods like map
or filter
are missing, so this syntax is still useful:
[...document.querySelectorAll(".myclass")].map(
(element, index, array) => {
// do stuff
}
);
[...document.querySelectorAll(".myclass")].map(element => element.innerHTML);
getElementsByClassName
returns HTMLCollection in modern browsers.
which is
array-like object similar to arguments which is iteratable by for...of
loop see below what MDN doc is saying about it:
The for...of statement creates a loop iterating over iterable objects, including: built-in String, Array, Array-like objects (e.g., arguments or NodeList), TypedArray, Map, Set, and user-defined iterables. It invokes a custom iteration hook with statements to be executed for the value of each distinct property of the object.
example
for (const element of document.getElementsByClassName("classname")){
element.style.display="none";
}
As already said, getElementsByClassName
returns a HTMLCollection, which is defined as
[Exposed=Window]
interface HTMLCollection {
readonly attribute unsigned long length;
getter Element? item(unsigned long index);
getter Element? namedItem(DOMString name);
};
Previously, some browsers returned a NodeList instead.
[Exposed=Window]
interface NodeList {
getter Node? item(unsigned long index);
readonly attribute unsigned long length;
iterable<Node>;
};
The difference is important, because DOM4 now defines NodeLists as iterable.
According to Web IDL draft,
Objects implementing an interface that is declared to be iterable support being iterated over to obtain a sequence of values.
Note: In the ECMAScript language binding, an interface that is iterable will have “entries”, “forEach”, “keys”, “values” and @@iterator properties on its interface prototype object.
That means that, if you want to use forEach
, you can use a DOM method which returns a NodeList, like querySelectorAll.
document.querySelectorAll(".myclass").forEach(function(element, index, array) {
// do stuff
});
Note this is not widely supported yet. Also see forEach method of Node.childNodes?
Is the result of getElementsByClassName an Array?
No
If not, what is it?
As with all DOM methods that return multiple elements, it is a NodeList, see https://developer.mozilla.org/en/DOM/document.getElementsByClassName
Edit: Although the return type has changed in new versions of HTML (see Tim Down's updated answer), the code below still works.
As others have said, it's a NodeList. Here's a complete, working example you can try:
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<script>
function findTheOddOnes()
{
var theOddOnes = document.getElementsByClassName("odd");
for(var i=0; i<theOddOnes.length; i++)
{
alert(theOddOnes[i].innerHTML);
}
}
</script>
</head>
<body>
<h1>getElementsByClassName Test</h1>
<p class="odd">This is an odd para.</p>
<p>This is an even para.</p>
<p class="odd">This one is also odd.</p>
<p>This one is not odd.</p>
<form>
<input type="button" value="Find the odd ones..." onclick="findTheOddOnes()">
</form>
</body>
</html>
This works in IE 9, FF 5, Safari 5, and Chrome 12 on Win 7.