Swift循环遍历集合方法

 

第一种方式：for-in循环

OC延续了C语言的for循环，在Swift中被完全改造，咱们没法再使用传统形式的for循环了

遍历数组和字典：

 1  //遍历数组
 2     let iosArray = ["L", "O", "V", "E", "I", "O", "S"]
 3 
 4     for index in 0...6 {
 5         print(iosArray[index])
 6     }
 7 
 8     for index in 0..<6 {
 9         print(iosArray[index])
10     }
11 
12     for element in iosArray {
13         print(element)
14     }
15 
16     //遍历字典
17     let iosDict = ["1": "one", "2": "two", "3": "three", "4": "four"]
18     for (key, value) in iosDict {
19         print("\(key): \(value)")
20     }
21 
22     //单独遍历字典的key和value
23     let keys = iosDict.keys
24     for k in keys {
25         print(k)
26     }
27 
28     let values = iosDict.values
29     for v in values {
30         print(v)
31     }

 

---

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

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

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

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

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

也就是说之后遇到涉及范围的状况均可以尝试0...6这种形式，看看是否能够迅速获取指定范围内的元素，可用的地方还有不少，小伙伴本身掘金吧。

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

---

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

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

二、
单独遍历字典的key个value时，须要注意的是，keys和values并非Array，所以没法直接使用keys[0]的形式访问，他们实际的类型是LazyMapCollection<[Key : Value], Key>，显然不是一个数组。固然咱们能够将他们转换成数组，以下：

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

因为字典是无序的，全部这么作的意义并不大。

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

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

反向遍历

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

一、如上不管是这种索引方式仍是快速遍历，均可直接调用reversed()函数轻松实现反向遍历。0...6

二、
对于字典的反向遍历，有些小伙伴可能会有些疑问，字典是无序的，反向和正向遍历有区别吗，彷佛意义不大。这里须要说明的是，字典的无序是说不保证顺序，可是在内存中是按照顺序排列的，只是这种顺序不必定按照咱们存入或者编码的顺序排列，所以字典的反向遍历也是有意义的。

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

拓展：reversed()函数其实是返回给咱们一个顺序彻底颠倒的集合，那么咱们就能够利用这个函数获得一个倒序的集合，很是方便，代码以下：

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

---

forEach遍历

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

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

 

注意： 一、不能使用“break”或者“continue”退出遍历； 二、使用“return”结束当前循环遍历，这种方式只是结束了当前闭包内的循环遍历，并不会跳事后续代码的调用。

---

stride遍历

• stride遍历分为
•  stride(from: <#T##Strideable#>, to: <#T##Strideable#>, by: <#T##Comparable & SignedNumeric#>)
•  stride(from: <#T##Strideable#>, through: <#T##Strideable#>, by: <#T##Comparable & SignedNumeric#>)

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

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

一、

正如stride单词的含义“大步跨过”，使用这种方式遍历的好处天然是能够灵活的根据本身的需求遍历，好比咱们有时须要遍历索引为偶数或者基数的元素，或者每隔3个元素遍历一次等等相似的需求均可以轻松实现；

二、
stride遍历一样能够实现正向和反向的遍历，在by后面添加正数表示递增的正向遍历，添加负数表示递减的反向遍历；

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

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

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

正向遍历

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

 

注意： 一、(n, c)中n表示元素的输入顺序，c表示集合中的每个元素； 二、因为数组是有序的，因此在数组中n天然也能够表示每个元素在数组中索引，而字典是无序的，可是n依然会按照0、一、2...的顺序输入，所以不能够表明在字典中的索引。

---

反向遍历

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

 

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