《golang设计模式》第三部分·行为型模式-04-迭代器模式（Iterator）

1. 概念

迭代器（Iterator）能够在不暴露聚合体内部表示的情况下，向客户端提供遍历聚合元素的方法。

1.1 角色

• InterfaceAggregate（抽象聚合）：定义存储、添加、删除聚合元素以及创建迭代器对象的接口
• ConcreteAggregate（具体聚合）：实现抽象聚合类。它的方法可以返回一个具体迭代器的实例
• Iterator（抽象迭代器）：定义访问和遍历聚合元素的接口，通常包含 hasNext()、next() 等方法
• Concretelterator（具体迭代器）：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。

1.2 类图

2. 代码示例

2.1 需求

实例化一个具体聚合，创建一个迭代器实例，用迭代器遍历这个聚合。

迭代器通常还会有查看首元素、尾元素、指针位置等方法，有兴趣可以自己试一下，这个简单示例里不写了。

2.2 代码

• 代码

package main

import "fmt"

// 定义抽象迭代器
type Iterator interface {
	HasNext() bool
	Next() interface{}
}

// 定义具体迭代器
type ConcreteIterator struct {
	//它关联具体聚合
	aggregate *ConcreteAggregate
	index     int
}

// 定义方法，查看迭代是否结束
func (i *ConcreteIterator) HasNext() bool {
	return i.index < len(i.aggregate.items)
}

// 定义方法，返回下一个节点
func (i *ConcreteIterator) Next() interface{} {
	if i.HasNext() {
		item := i.aggregate.items[i.index]
		i.index++
		return item
	}
	return nil
}

// 定义抽象聚合
type Aggregate interface {
	CreateIterator() Iterator
	AddItem(item interface{})
}

// 定义具体聚合
type ConcreteAggregate struct {
	items []interface{}
}

// 定义方法，创建迭代器
func (a *ConcreteAggregate) CreateIterator() Iterator {
	return &ConcreteIterator{aggregate: a}
}

// 定义方法，添加item（为了测试方便，和迭代器方法无关）
func (a *ConcreteAggregate) AddItem(item interface{}) {
	a.items = append(a.items, item)
}

func main() {
	//实例化一个聚合，加入三个Item，他们的类型可以不同
	var aggregate Aggregate
	aggregate = &ConcreteAggregate{}
	aggregate.AddItem("Item 1")
	aggregate.AddItem(2)
	aggregate.AddItem("Item 3")

	//实例化一个迭代器
	iterator := aggregate.CreateIterator()
	//验证结果
	for iterator.HasNext() {
		item := iterator.Next()
		fmt.Println(item)
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

• 输出

Item 1
2
Item 3
1
2
3

2.3 类图

---