go实现简单迭代器
# 简易切片迭代器
Go 语言遍历切片使用的是for range
来实现;如果学过java
或者python
他们都有一个类似的迭代器的功能,我们来模拟实现一下。
package main
import "fmt"
type Iterator struct {
data []int
index int // 索引
}
func NewIterator(data []int) *Iterator {
return &Iterator{data: data}
}
func (this *Iterator) HasNext() bool {
if this.data == nil || len(this.data) == 0 {
return false
}
return this.index < len(this.data)
}
func (this *Iterator) Next() int {
defer func() {
this.index++
}()
return this.data[this.index]
}
func main() {
ints := []int{1, 2, 3, 4, 5}
iterator := NewIterator(ints)
for iterator.HasNext() {
fmt.Println(iterator.Next())
}
//for index, v := range ints {
// fmt.Println(index, v)
//}
}
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
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
# 支持多类型和封装
抽离出公共的方法以及属性
重新新建一个lib/iterator
包路径,将上面的文件修改为专属于int
类型的迭代器
iterator.go
package iterator
type Iterator struct {
index int // 索引
len int // 长度
}
func (this *Iterator) HasNext() bool {
if this.len == 0 {
return false
}
return this.index < this.len
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
2
3
4
5
6
7
8
9
10
11
12
13
14
对原先的int
迭代器改造
package iterator
type IntIterator struct {
*Iterator
data []int
}
func NewIntIterator(data []int) *IntIterator {
return &IntIterator{data: data, Iterator: &Iterator{len: len(data)}}
}
func (this *IntIterator) Next() int {
defer func() {
this.index++
}()
return this.data[this.index]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
现在如果需要多种类型的迭代器,我们可以新增一个str_interator.go
来实现
package iterator
type StringIterator struct {
*Iterator
data []string
}
func NewStringIterator(data []string) *StringIterator {
return &StringIterator{data: data, Iterator: &Iterator{len: len(data)}}
}
func (this *StringIterator) Next() string {
defer func() {
this.index++
}()
return this.data[this.index]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
这样我们通过
Go
的结构体嵌套完成了这种多类型的切片迭代器
测试代码
package main
import "chanpro/lib/iterator"
func main() {
ints := []int{1, 2, 3, 4, 5}
strs := []string{"a", "b", "c", "d", "e"}
iter := iterator.NewIntIterator(ints)
for iter.HasNext() {
println(iter.Next())
}
str_iter := iterator.NewStringIterator(strs)
for str_iter.HasNext() {
println(str_iter.Next())
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
编辑 (opens new window)
上次更新: 2022/05/31, 23:54:39