The following are all built-in JavaScript iterators:

• TheArray Iterator returned byArray.prototype.values(),Array.prototype.keys(),Array.prototype.entries(),Array.prototype[Symbol.iterator](),TypedArray.prototype.values(),TypedArray.prototype.keys(),TypedArray.prototype.entries(),TypedArray.prototype[Symbol.iterator](), andarguments[Symbol.iterator]().
• TheString Iterator returned byString.prototype[Symbol.iterator]().
• TheMap Iterator returned byMap.prototype.values(),Map.prototype.keys(),Map.prototype.entries(), andMap.prototype[Symbol.iterator]().
• TheSet Iterator returned bySet.prototype.values(),Set.prototype.keys(),Set.prototype.entries(), andSet.prototype[Symbol.iterator]().
• TheRegExp String Iterator returned byRegExp.prototype[Symbol.matchAll]() andString.prototype.matchAll().
• TheGenerator object returned bygenerator functions.
• TheSegments Iterator returned by the[Symbol.iterator]() method of theSegments object returned byIntl.Segmenter.prototype.segment().
• TheIterator Helper returned by iterator helper methods such asIterator.prototype.filter() andIterator.prototype.map().

Web APIs may return iterators too. Some reuse core JavaScript iterators while others define their own iterators. For example:

• Array-Like objects such asNodeList return anArray Iterator from their respective methodskeys(),values(),entries(), and[Symbol.iterator]().
• Map-Like objects from Web APIs such asHeaders return their own iterator type likeHeaders Iterator from their respective methodskeys(),values(),entries(), and[Symbol.iterator]().
• Set-Like objects from Web APIs such asFontFaceSet return their own iterator type likeFontFaceSet Iterator from their respective methodskeys(),values(),entries(), and[Symbol.iterator]().

Each of these iterators have a distinct prototype object, which defines thenext() method used by the particular iterator. For example, all string iterator objects inherit from a hidden objectStringIteratorPrototype, which has anext() method that iterates this string by code points.StringIteratorPrototype also has a[Symbol.toStringTag] property whose initial value is the string"String Iterator". This property is used inObject.prototype.toString(). Similarly, other iterator prototypes also have their own[Symbol.toStringTag] values, which are the same as the names given above.

All of these prototype objects inherit fromIterator.prototype, which provides a[Symbol.iterator]() method that returns the iterator object itself, making the iterator alsoiterable.

TheIterator class itself provides some helper methods for working with iterators. For example, you may be tempted to do the following:

const nameToDeposit = new Map([  ["Anne", 1000],  ["Bert", 1500],  ["Carl", 2000],]);const totalDeposit = [...nameToDeposit.values()].reduce((a, b) => a + b);

This first converts the iterator returned byMap.prototype.values() to an array, then uses theArray.prototype.reduce() method to calculate the sum. However, this both creates an intermediate array and iterates the array twice. Instead, you can use thereduce() method of the iterator itself:

const totalDeposit = nameToDeposit.values().reduce((a, b) => a + b);

This method may be more efficient, especially memory-wise, because it only iterates the iterator once, without memorizing any intermediate values. Iterator helper methods are necessary to work with infinite iterators:

function* fibonacci() {  let current = 1;  let next = 1;  while (true) {    yield current;    [current, next] = [next, current + next];  }}const seq = fibonacci();const firstThreeDigitTerm = seq.find((n) => n >= 100);

You cannot convertseq to an array, because it is infinite. Instead, you can use thefind() method of the iterator itself, which only iteratesseq as far as necessary to find the first value that satisfies the condition.

You will find many iterator methods analogous to array methods, such as:

Iterator.prototype.drop() andIterator.prototype.take() combined are somewhat analogous toArray.prototype.slice().

Among the iterator helper methods,filter(),flatMap(),map(),drop(), andtake() return a newIterator Helper object. The iterator helper is also anIterator instance, making these helper methods chainable. All iterator helper objects inherit from a common prototype object, which implements the iterator protocol:

next()

Calls thenext() method of the underlying iterator, applies the helper method to the result, and returns the result.

return()

Calls thereturn() method of the underlying iterator, and returns the result.

The iterator helper shares the same data source as the underlying iterator, so iterating the iterator helper causes the underlying iterator to be iterated as well. There is no way to "fork" an iterator to allow it to be iterated multiple times.

const it = [1, 2, 3].values();const it2 = it.drop(0); // Essentially a copyconsole.log(it.next().value); // 1console.log(it2.next().value); // 2console.log(it.next().value); // 3

There are two kinds of "iterators": objects that conform to theiterator protocol (which, at its minimum, only requires the presence of anext() method), and objects that inherit from theIterator class, which enjoy the helper methods. They do not entail each other — objects that inherit fromIterator do not automatically become iterators, because theIterator class does not define anext() method. Instead, the object needs to define anext() method itself. Aproper iterator is one that both conforms to the iterator protocol and inherits fromIterator, and most code expect iterators to be proper iterators and iterables to return proper iterators. To create proper iterators, define a class that extendsIterator, or use theIterator.from() method.

class MyIterator extends Iterator {  next() {    // …  }}const myIterator = Iterator.from({  next() {    // …  },});

Iterator()

Intended to beextended by other classes that create iterators. Throws an error when constructed by itself.

Iterator.from()

Creates a newIterator object from an iterator or iterable object.

These properties are defined onIterator.prototype and shared by allIterator instances.

Iterator.prototype.constructor

The constructor function that created the instance object. ForIterator instances, the initial value is theIterator constructor.

Iterator.prototype[Symbol.toStringTag]

The initial value of the[Symbol.toStringTag] property is the string"Iterator". This property is used inObject.prototype.toString().

Note:Unlike the[Symbol.toStringTag] on most built-in classes,Iterator.prototype[Symbol.toStringTag] is writable for web compatibility reasons.

Iterator.prototype.drop()

Returns a new iterator helper object that skips the given number of elements at the start of this iterator.

Iterator.prototype.every()

Tests whether all elements produced by the iterator pass the test implemented by the provided function.

Iterator.prototype.filter()

Returns a new iterator helper object that yields only those elements of the iterator for which the provided callback function returnstrue.

Iterator.prototype.find()

Returns the first element produced by the iterator that satisfies the provided testing function. If no values satisfy the testing function,undefined is returned.

Iterator.prototype.flatMap()

Returns a new iterator helper object that takes each element in the original iterator, runs it through a mapping function, and yields elements returned by the mapping function (which are contained in another iterator or iterable).

Iterator.prototype.forEach()

Executes a provided function once for each element produced by the iterator.

Iterator.prototype.map()

Returns a new iterator helper object that yields elements of the iterator, each transformed by a mapping function.

Iterator.prototype.reduce()

Executes a user-supplied "reducer" callback function on each element produced by the iterator, passing in the return value from the calculation on the preceding element. The final result of running the reducer across all elements is a single value.

Iterator.prototype.some()

Tests whether at least one element in the iterator passes the test implemented by the provided function. It returns a boolean value.

Iterator.prototype.take()

Returns a new iterator helper object that yields the given number of elements in this iterator and then terminates.

Iterator.prototype.toArray()

Creates a newArray instance populated with the elements yielded from the iterator.

Iterator.prototype[Symbol.iterator]()

Returns the iterator object itself. This allows iterator objects to also be iterable.

All built-in iterators are also iterable, so you can use them in afor...of loop:

const arrIterator = [1, 2, 3].values();for (const value of arrIterator) {  console.log(value);}// Logs: 1, 2, 3

• Polyfill ofIterator incore-js
• es-shims polyfill ofIterator and associated helpers
• function*
• Iteration protocols