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()函數。