在Ruby中，塊（Block）和迭代器（Iterator）是實現循環和數據處理的重要工具。以下是一些與塊和迭代器相關的常用設計模式：

1. 適配器模式（Adapter Pattern）

適配器模式用于將一個類的接口轉換成客戶端所期望的另一個接口形式。在Ruby中，塊可以作為適配器使用，將一個集合適配成另一個集合的行為。

class ArrayAdapter
  def initialize(array)
    @array = array
  end

  def each(&block)
    @array.each(&block)
  end
end

# 使用示例
array = [1, 2, 3]
adapter = ArrayAdapter.new(array)
adapter.each { |item| puts item }

2. 裝飾器模式（Decorator Pattern）

裝飾器模式允許在不修改原始類的情況下，動態地添加新的功能。在Ruby中，塊可以作為裝飾器使用，為集合添加額外的操作。

class ArrayDecorator
  def initialize(array)
    @array = array
  end

  def each(&block)
    @array.each(&block)
  end

  def log_each(&block)
    each do |item|
      block.call(item)
      puts "Logged: #{item}"
    end
  end
end

# 使用示例
array = [1, 2, 3]
decorator = ArrayDecorator.new(array)
decorator.log_each { |item| puts item }

3. 組合模式（Composite Pattern）

組合模式允許將對象組合成樹形結構以表示“部分-整體”的層次結構。在Ruby中，塊可以作為組合的一部分，處理集合中的元素。

class CompositeCollection
  attr_accessor :elements

  def initialize
    @elements = []
  end

  def add(element)
    @elements << element
  end

  def each(&block)
    @elements.each(&block)
  end
end

# 使用示例
collection = CompositeCollection.new
collection.add("Element 1")
collection.add("Element 2")
collection.add("Element 3")

collection.each { |element| puts element }

4. 迭代器模式（Iterator Pattern）

迭代器模式提供一種方法順序訪問一個聚合對象中各個元素，而又不暴露其內部的表示。在Ruby中，迭代器模式是內置的，通過each方法實現。

class MyCollection
  def initialize
    @items = []
  end

  def add(item)
    @items << item
  end

  def each(&block)
    @items.each(&block)
  end
end

# 使用示例
collection = MyCollection.new
collection.add(1)
collection.add(2)
collection.add(3)

collection.each { |item| puts item }

5. 策略模式（Strategy Pattern）

策略模式定義一系列算法，把它們一個個封裝起來，并且使它們可以相互替換。在Ruby中，塊可以作為策略使用，實現不同的處理邏輯。

class Strategy
  def execute(&block)
    block.call
  end
end

class AddStrategy < Strategy
  def execute(&block)
    block.call(1)
  end
end

class MultiplyStrategy < Strategy
  def execute(&block)
    block.call(2)
  end
end

# 使用示例
strategy = AddStrategy.new
strategy.execute { |x| puts x + 1 } # 輸出 2

strategy = MultiplyStrategy.new
strategy.execute { |x| puts x * 2 } # 輸出 4

這些設計模式可以幫助你更靈活地使用塊和迭代器，實現更復雜的功能和邏輯。