🧩 Iterator Pattern

✅ Intent

• Abstract the traversal of a collection so that the iteration logic is reusable and separate from processing logic
• Focus on the "traversal mechanism", not the "business logic"

✅ Motivation

• If your Facade or Proxy involves iteration or sequences of actions (e.g. multi-step flows), you can decouple that traversal logic using an iterator
• Replaces repeated for loops scattered across multiple classes

✅ When to Use

• You have a sequence of steps or items (auth, load, audit, etc.)
• You want to encapsulate iteration and make the flow reusable and maintainable

✅ Code Example

TypeScript

interface Step {
  execute(context: Record<string, any>): void;
}

class AuthStep implements Step {
  execute(context: Record<string, any>): void {
    console.log(`ユーザー認証: ${context.userId}`);
    context.authenticated = true;
  }
}

class LoadProfileStep implements Step {
  execute(context: Record<string, any>): void {
    if (!context.authenticated) throw new Error("未認証");
    console.log(`プロフィール取得: ${context.userId}`);
    context.profile = { name: "Hiroshi", id: context.userId };
  }
}

class AuditStep implements Step {
  execute(context: Record<string, any>): void {
    console.log("[監査ログ] プロフィール表示");
  }
}

class UserProfileFlow {
  private steps: Step[] = [];

  constructor() {
    this.steps = [new AuthStep(), new LoadProfileStep(), new AuditStep()];
  }

  execute(userId: string) {
    const context: Record<string, any> = { userId };
    for (const step of this.steps) {
      step.execute(context);
    }
    console.log(context.profile);
  }
}

// 利用例
const flow = new UserProfileFlow();
flow.execute("user-123");

PHP

<?php

interface Step {
  public function execute(array &$context): void;
}

class AuthStep implements Step {
  public function execute(array &$context): void {
    echo "ユーザー認証: {$context['userId']}\n";
    $context['authenticated'] = true;
  }
}

class LoadProfileStep implements Step {
  public function execute(array &$context): void {
    if (!($context['authenticated'] ?? false)) {
      throw new Exception("未認証");
    }
    echo "プロフィール取得: {$context['userId']}\n";
    $context['profile'] = ['name' => 'Hiroshi', 'id' => $context['userId']];
  }
}

class AuditStep implements Step {
  public function execute(array &$context): void {
    echo "[監査ログ] プロフィール表示\n";
  }
}

class UserProfileFlow {
  private array $steps;

  public function __construct() {
    $this->steps = [new AuthStep(), new LoadProfileStep(), new AuditStep()];
  }

  public function execute(string $userId): void {
    $context = ['userId' => $userId];
    foreach ($this->steps as $step) {
      $step->execute($context);
    }
    print_r($context['profile']);
  }
}

// 利用例
$flow = new UserProfileFlow();
$flow->execute("user-123");

Python

from abc import ABC, abstractmethod

class Step(ABC):
    @abstractmethod
    def execute(self, context: dict):
        pass

class AuthStep(Step):
    def execute(self, context: dict):
        print(f"ユーザー認証: {context['user_id']}")
        context['authenticated'] = True

class LoadProfileStep(Step):
    def execute(self, context: dict):
        if not context.get('authenticated'):
            raise Exception("未認証")
        print(f"プロフィール取得: {context['user_id']}")
        context['profile'] = {"name": "Hiroshi", "id": context['user_id']}

class AuditStep(Step):
    def execute(self, context: dict):
        print("[監査ログ] プロフィール表示")

class UserProfileFlow:
    def __init__(self):
        self.steps: list[Step] = [AuthStep(), LoadProfileStep(), AuditStep()]

    def execute(self, user_id: str):
        context = {"user_id": user_id}
        for step in self.steps:
            step.execute(context)
        print(context["profile"])

# 利用例
flow = UserProfileFlow()
flow.execute("user-123")

✅ Explanation

This code uses the Iterator pattern to define a user flow made of sequential processing steps like authentication, profile loading, and audit logging. Each step is independent and follows a shared interface.

This approach improves maintainability, allows future extension (new steps), and isolates control flow from implementation details.

1. Iterator Pattern Overview

• Aggregate: A collection that exposes a unified interface to iterate over its elements

  • Here: UserProfileFlow

• Iterator: Mechanism to traverse the elements of the collection

  • Here: for...of loop over the steps list

• Concrete Element: The individual elements of the collection

  • Here: AuthStep, LoadProfileStep, AuditStep

2. Key Classes and Responsibilities

• Step

  • Common interface for all steps with an execute(context: object) method

• AuthStep, LoadProfileStep, AuditStep

  • Concrete implementations of Step, each encapsulating a part of the logic:
    • AuthStep: Verifies authentication
    • LoadProfileStep: Loads user profile
    • AuditStep: Logs the access

• UserProfileFlow

  • Aggregates all steps
  • execute() method traverses each step and applies it sequentially

3. UML Class Diagram

4. Benefits of the Iterator Pattern

• Clear control flow: Easy to understand and maintain ordered execution of steps
• Extensible: New steps can be added without modifying the flow logic
• Reusability: Common iteration logic is centralized and separated from business rules

This design is particularly effective when working with flows or pipelines composed of multiple discrete stages. It keeps logic modular and enables consistent iteration across different contexts.