Understanding the Iterator Design Pattern in JavaScript

TL;DR: This article discusses the iterator design pattern in JavaScript, providing a deep dive into how it functions, why it’s used, and how to implement it. The iterator design pattern enables access to elements of a collection sequentially, without exposing the underlying representation. Although not commonly used in JavaScript currently, it will become an integral part of the language specification soon.


JavaScript, as a language, has built-in iteration capabilities. Whether it’s the array iteration methods, such as for and forEach, or the forIn loop for objects, JavaScript offers several ways to iterate. However, the iterator design pattern stands apart due to its unique characteristics. It doesn’t run in a synchronous loop, and it keeps track of processed items. The goal of this article is to explain the iterator pattern in detail, showcasing its implementation in JavaScript.

Iterating with the Iterator Pattern

The iterator design pattern allows sequential access to elements within a collection without revealing the collection’s internal workings. In other words, we manually choose when to extract the data of the next item. It’s common for this pattern to use a next() method that returns the next item in the collection. Some libraries even provide additional methods such as hasNext, isDone, first, and reset().

With JavaScript ES7, iterators will become a core part of the language. Until then, we have to build our own. Below we describe the steps to create an iterator using JavaScript, referencing the MDN Web Docs for more information.

Step 1 – Implementing the Iterator

In iterator.js, we start by defining an Iterator constructor, which receives a collection of items and stores this collection as a property of the object. The object also has an index property initialized to 0 to track the items that have been processed. The iterator includes a set of methods:

  • next(): Returns the next item in the collection and increments the index by 1.
  • isDone(): Returns true once all the items in the collection have been iterated.
  • reset(): Resets the index back to 0 for a fresh iteration.
  • take(numberOfItems): Returns a specified number of items and updates the index accordingly.

We also define a factory pattern build method to handle various input types and create an appropriate iterator.

Step 2 – Initializing the Iterator

In init.js, we load the iterator and define test data, including an array and a string. We then use the build method to create iterators for each data set.

This implementation allows us to manually control the iteration process, enabling sequential data extraction whenever needed.

Step 3 – Utilizing the Iterator

The iterator can now be used in the main.js file. We can now call the iterator methods to iterate through the collections.


While not as common in JavaScript as other patterns, the iterator pattern brings several benefits. It decouples the processing of a collection of items from the collection itself, promoting flexibility. This design pattern doesn’t need to know the data or its type, as the iterator is designed to handle all eventualities. As JavaScript evolves, the iterator design pattern will soon become a core component of the language specification, highlighting its importance in modern web development. By understanding and implementing this pattern, developers can write more efficient and maintainable code.