正文

Swift循环遍历集合的方法总结分享

︶ㄣ速达网 メ
米米素材网V管理员 / 阅读
0705

SWIFT是苹果于2014年WWDC发布的新开发语言，可与Objective-C*共同运行于Mac OS和iOS平台，用于搭建基于苹果平台的应用程序。这篇文章主要给大家总结介绍了关于Swift循环遍历集合的方法，如for-in循环、for循环以及基于块的遍历等方法，

前言

之前分享总结过OC循环遍历，文章点击这里：iOS遍历集合(NSArray，NSDictionary、NSSet)方法总结。随着Swift的逐渐完善，自己使用Swift开发的项目经验和知识逐渐积累，是时候总结一下Swift的循环遍历了。相信Swift一定会给你一些不一样的东西，甚至是惊喜，感兴趣的朋友们下面来一起看看吧。

Swift循环遍历集合的方法总结分享

第一种方式：for-in循环

OC延续了C语言的for循环，在Swift中被彻底改造，我们无法再使用传统形式的for循环了

遍历数组和字典：

?
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
//遍历数组
let iosArray = ["L", "O", "V", "E", "I", "O", "S"]
 
for index in 0...6 {
print(iosArray[index])
}
 
for index in 0..<6 {
print(iosArray[index])
}
 
for element in iosArray {
print(element)
}
 
//遍历字典
let iosDict = ["1": "one", "2": "two", "3": "three", "4": "four"]
for (key, value) in iosDict {
print("\(key): \(value)")
}
 
//单独遍历字典的key和value
let keys = iosDict.keys
for k in keys {
print(k)
}
 
let values = iosDict.values
for v in values {
print(v)
}

如上遍历数组使用了2种方式

1、第一种方式是Swift中普通的for循环语法，在索引index和遍历范围0...6之间用关键字in，这里要注意0...6的表示的范围是：0<= index <= 6，而0..<6表示的是：0<= index < 6，这里要注意的是没有：0<..6的形式。只要熟悉了Swift语法，以上这些并不难理解。

拓展1：0...6的形式还可以取出制定范围的数组中的元素，代码如下：

?
1
2
3
4
5
6
7
8
let sectionArray = iosArray[1...4]
print(sectionArray)
输出：
▿ 4 elements
- 0 : "O"
- 1 : "V"
- 2 : "E"
- 3 : "I"

拓展2：0...6的形式还可以用来初始化创建数组，代码如下：

?
1
2
3
4
5
6
7
8
9
10
11
let numbers = Array(1...7)
print(numbers)
输出：
▿ 7 elements
- 0 : 1
- 1 : 2
- 2 : 3
- 3 : 4
- 4 : 5
- 5 : 6
- 6 : 7

也就是说以后遇到涉及范围的情况都可以尝试0...6这种形式，看看是否可以迅速获取指定范围内的元素，可用的地方还有很多，小伙伴自己掘金吧。

2、第二种方式类似于OC中的快速遍历，不需要索引直接就可以访问到数组中的元素，也很好理解。

字典的遍历可分为同时或者分别遍历key和value

1、同时遍历key和value时利用了Swift的元组，元组可以把不同类型的值组合成一个复合的值，使用起来非常方便，这样就可以同时拿到字典的key和value了。

2、单独遍历字典的key个value时，需要注意的是，keys和values并不是Array，因此无法直接使用keys[0]的形式访问，他们实际的类型是LazyMapCollection<[Key : Value], Key> ，显然不是一个数组。

当然我们可以将他们转换成数组，如下：

?
1
2
3
//将字典的kyes转换成数组
let keys = Array(iosDict.keys)
print(keys[0])

由于字典是无序的，所有这么做的意义并不大。

第二种方式：Swift为for循环带来的惊喜

将以下内容单拿出来作为第二种方式不太合适，其实这部分还是属于Swift的for-in循环，单独拿出来是出于对这种方式的喜爱，也让大家在看的时候更加醒目。

反向遍历

?
1
2
3
4
5
6
7
8
9
10
11
12
13
//倒序遍历数组
for index in (0...6).reversed() {
print(iosArray[index])
}
 
for element in iosArray.reversed() {
print(element)
}
 
//倒序遍历字典
for (key, value) in iosDict.reversed() {
print("\(key): \(value)")
}

1、如上无论是0...6这种索引方式还是快速遍历，都可直接调用reversed()函数轻松实现反向遍历。

2、对于字典的反向遍历，有些小伙伴可能会有些疑问，字典是无序的，反向和正向遍历有区别吗，似乎意义不大。这里需要说明的是，字典的无序是说不保证顺序，但是在内存中是按照顺序排列的，只是这种顺序不一定按照我们存入或者编码的顺序排列，因此字典的反向遍历也是有意义的。

3、看过我去年总结的OC循环遍历的小伙伴一定还记得，当我们需要在遍历集合时改变集合中的元素时，正向遍历会偶尔出现崩溃的问题，尤其是数据量较大时几乎每次都会崩溃，当我们使用反向遍历时就没有崩溃的问题了，在Swift中为了保证程序的稳定，也建议在遍历集合需要修改集合元素时采用反向遍历。

拓展：reversed()函数实际上是返回给我们一个顺序完全颠倒的集合，那么我们就可以利用这个函数得到一个倒序的集合，非常方便，代码如下：

?
1
2
3
//获取倒序数组
let reversedArray = Array(iosArray.reversed())
print(reversedArray)

forEach遍历

如果还有小伙伴认为for-in遍历繁琐，Swift还提供了一种更加简洁的遍历方式forEach,代码如下：

?
1
2
3
4
5
6
7
8
9
//使用forEach正向遍历
iosArray.forEach { (word) in
print(word)
}
 
//使用forEach的反向遍历
iosArray.reversed().forEach { (word) in
print(word)
}

注意：

1、不能使用“break”或者“continue”退出遍历；

2、使用“return”结束当前循环遍历，这种方式只是结束了当前闭包内的循环遍历，并不会跳过后续代码的调用。

stride遍历

stride遍历分为

?
1
stride<T : Strideable>(from start: T, to end: T, by stride: T.Stride)

和

?
1
stride<T : Strideable>(from start: T, through end: T, by stride: T.Stride)

两种遍历方式，代码如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//stride正向遍历
for index in stride(from: 1, to: 6, by: 1) {
print(index)
print(iosArray[index])
}
 
//stride正向跳跃遍历
for index in stride(from: 0, to: 6, by: 2) {
print(index)
print(iosArray[index])
}
 
//stride反向遍历
for index in stride(from: 6, to: 1, by: -1) {
print(index)
print(iosArray[index])
}
 
//stride through正向遍历
for index in stride(from: 0, through: 6, by: 1) {
print(index)
print(iosArray[index])
}

1、正如stride单词的含义“大步跨过”，使用这种方式遍历的好处自然是可以灵活的根据自己的需求遍历，比如我们有时需要遍历索引为偶数或者基数的元素，或者每隔3个元素遍历一次等等类似的需求都可以轻松实现；

2、stride遍历同样可以实现正向和反向的遍历，在by后面添加正数表示递增的正向遍历，添加负数表示递减的反向遍历；

3、to和through两种遍历方式的不同在于to不包含后面的索引，而through包含后面的索引，以to: 6和through: 6为例，to：<6或者>6，through：<=6或者>=6，至于是<还是>取决于是正向遍历还是反向遍历。

第三种方式：基于块的遍历

OC拥有一套很优雅基于快的遍历，Swift保持了这套优秀的接口，下面来看看Swift是如何使用的。

正向遍历

?
1
2
3
4
5
6
7
8
9
//遍历数组
for (n, c) in iosArray.enumerated() {
print("\(n): \(c)")
}
 
//遍历字典
for (n, c) in iosDict.enumerated() {
print("\(n): \(c)")
}

注意：

1、(n, c)中n表示元素的输入顺序，c表示集合中的每一个元素；

2、由于数组是有序的，所以在数组中n自然也可以表示每一个元素在数组中索引，而字典是无序的，但是n依然会按照0、1、2...的顺序输入，因此不可以代表在字典中的索引。

反向遍历

?
1
2
3
4
5
6
7
8
9
//反向遍历数组
for (n, c) in iosArray.enumerated().reversed() {
print("\(n): \(c)")
}
 
//反向遍历字典
for (n, c) in iosDict.enumerated().reversed() {
print("\(n): \(c)")
}

反向遍历就是直接在enumerated()函数后调用reversed()函数。

总结

在总结OC循环遍历时，笔者极力推崇基于块的循环遍历，因为相比较其他的遍历方式，基于块的循环遍历实在是集优雅与实用于一体的尤物，但是在Swift中情况发生了一些变化。

1、以上列举了3大种遍历方式，其实这种分类方式并不严谨，他们只是展示的形式不一样，本质上都属于for-in循环的变种，都是基于枚举的循环遍历，所以大家不必太较真他们的本质区别，在形式上区分开就可以，不影响我们的使用；

2、在OC中除了少数情况我们需要使用for (int i = 0; i < n; i++) 的方式，我们都推荐使用基于枚举的快速遍历。在Swift中舍弃了for (int i = 0; i < n; i++)的形式，带给我们for index in 0...6，这并不只是语法格式的变化，从本质上已经完全不一样，使用起来更加方便，也拥有更多的接口提供便利的功能。并且相比较其他的遍历方式也有很多优点，因此在Swift中我们无法一边倒的选择一种方式，应该根据情况选择合适的方法。

3、在OC中基于块的遍历还有一种情况是并发遍历，我在Swift中没有找到相应的方法，看了几千行代码也没有发现踪迹，有找到的小伙伴还请告知，感激不尽。当然并发遍历用的并不多，我们很多时候我们都希望集合的元素按序出现，在时间和效率上也没有区别。

结束语

抛开我们的使用习惯，Swift在很多时候都要比OC甚至其他编程语言更加简洁实用，虽然现在Swift编程很多还是依赖于OC，甚至Swift这种编译时的语言的动态性依然是基于OC的运行时，还有大量的类似于UIKit的库也都是基于OC。Swift集其他语言优点于一身又不失个性，从for循环等一系列小的地方的改变就可以看出其独特之处。完全取代OC还需时日，可此时投身Swift确是最好时机，你还在等什么？

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作能带来一定的帮助，如果有疑问大家可以留言交流，谢谢大家对米米素材网的支持。

原文链接：http://www.jianshu.com/p/9fae1a4746bb