Iterator Pattern

The Problem

A product catalog can be browsed in many ways — sorted by price, filtered by category, or paginated. Embedding each traversal in the collection class makes it bloated and hard to maintain. Adding a new traversal strategy requires modifying the collection.

The Solution

The Iterator pattern extracts each traversal strategy into its own iterator object. The product collection provides factory methods to create the appropriate iterator, and each iterator encapsulates its own traversal logic.

Structure

Iterator (Iterator<T> interface) — Declares hasNext(), next(), reset().
Concrete Iterators — PriceAscendingIterator, CategoryIterator, PaginatedIterator.
Aggregate / Collection — ProductCollection with factory methods for creating iterators.

Implementation

The collection holds 12 products across three categories (electronics, sports, books) with three traversal strategies:

PriceAscendingIterator — Products sorted by price low to high.
CategoryIterator — Products filtered by a specific category.
PaginatedIterator — Products grouped into pages of configurable size.

export interface Iterator<T> {
  hasNext(): boolean;
  next(): T;
  reset(): void;
}

export interface IterableCollection<T> {
  createIterator(): Iterator<T>;
}

export interface Product {
  id: string;
  name: string;
  price: number;
  category: string;
}

import { Iterator, Product } from './iterator.interface';

export class PriceAscendingIterator implements Iterator<Product> {
  private position = 0;
  private readonly sortedProducts: Product[];

  constructor(products: Product[]) {
    this.sortedProducts = [...products].sort((a, b) => a.price - b.price);
  }

  hasNext(): boolean {
    return this.position < this.sortedProducts.length;
  }

  next(): Product {
    if (!this.hasNext()) {
      throw new Error('No more elements');
    }
    const product = this.sortedProducts[this.position];
    this.position++;
    return product;
  }

  reset(): void {
    this.position = 0;
  }
}

import { Iterator, Product } from './iterator.interface';

export class CategoryIterator implements Iterator<Product> {
  private position = 0;
  private readonly filteredProducts: Product[];

  constructor(products: Product[], category: string) {
    this.filteredProducts = products.filter(
      (p) => p.category.toLowerCase() === category.toLowerCase(),
    );
  }

  hasNext(): boolean {
    return this.position < this.filteredProducts.length;
  }

  next(): Product {
    if (!this.hasNext()) {
      throw new Error('No more elements');
    }
    const product = this.filteredProducts[this.position];
    this.position++;
    return product;
  }

  reset(): void {
    this.position = 0;
  }
}

import { Iterator, Product } from './iterator.interface';

export class PaginatedIterator implements Iterator<Product[]> {
  private currentPage = 0;
  private readonly pages: Product[][];

  constructor(products: Product[], pageSize: number) {
    this.pages = [];
    for (let i = 0; i < products.length; i += pageSize) {
      this.pages.push(products.slice(i, i + pageSize));
    }
  }

  hasNext(): boolean {
    return this.currentPage < this.pages.length;
  }

  next(): Product[] {
    if (!this.hasNext()) {
      throw new Error('No more pages');
    }
    const page = this.pages[this.currentPage];
    this.currentPage++;
    return page;
  }

  reset(): void {
    this.currentPage = 0;
  }

  getTotalPages(): number {
    return this.pages.length;
  }
}

import { IterableCollection, Iterator, Product } from './iterator.interface';
import { PriceAscendingIterator } from './price-ascending.iterator';
import { CategoryIterator } from './category.iterator';
import { PaginatedIterator } from './paginated.iterator';

export class ProductCollection implements IterableCollection<Product> {
  private readonly products: Product[];

  constructor() {
    this.products = [
      { id: '1', name: 'Laptop', price: 999.99, category: 'electronics' },
      { id: '2', name: 'Headphones', price: 49.99, category: 'electronics' },
      { id: '3', name: 'Running Shoes', price: 89.99, category: 'sports' },
      { id: '4', name: 'Novel', price: 14.99, category: 'books' },
      { id: '5', name: 'Smartphone', price: 699.99, category: 'electronics' },
      { id: '6', name: 'Yoga Mat', price: 29.99, category: 'sports' },
      { id: '7', name: 'Cookbook', price: 24.99, category: 'books' },
      { id: '8', name: 'Tablet', price: 449.99, category: 'electronics' },
      { id: '9', name: 'Tennis Racket', price: 159.99, category: 'sports' },
      { id: '10', name: 'Science Fiction Anthology', price: 19.99, category: 'books' },
      { id: '11', name: 'Monitor', price: 349.99, category: 'electronics' },
      { id: '12', name: 'Basketball', price: 34.99, category: 'sports' },
    ];
  }

  createIterator(): Iterator<Product> {
    return this.createPriceAscendingIterator();
  }

  createPriceAscendingIterator(): PriceAscendingIterator {
    return new PriceAscendingIterator(this.products);
  }

  createCategoryIterator(category: string): CategoryIterator {
    return new CategoryIterator(this.products, category);
  }

  createPaginatedIterator(pageSize: number): PaginatedIterator {
    return new PaginatedIterator(this.products, pageSize);
  }

  getAll(): Product[] {
    return [...this.products];
  }

  getTotalCount(): number {
    return this.products.length;
  }
}

NestJS Integration

The ProductCollection is created in the controller and populated with sample data. The iterators are plain classes, not NestJS providers, since they hold traversal state specific to each request. The controller selects the appropriate iterator based on query parameters.

When to Use

You need to traverse a collection in multiple ways without modifying the collection class.
You want to hide the collection’s internal structure from clients.
You need uniform iteration over different types of collections.

When NOT to Use

The collection only ever needs one traversal strategy — a simple for loop or array method is clearer.
The collection is a simple array/list where built-in iterators are sufficient.

Composite

Compose objects into tree structures to represent part-whole hierarchies.

Factory Method

Define an interface for creating an object, but let subclasses decide which class to instantiate.

Visitor

Represent an operation to be performed on the elements of an object structure.