查看: 5039|回复: 0

[手机开发] Swift循环遍历集合方法

发表于 2018-2-21 08:00:04
第一种方式:for-in循环

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

遍历数组和字典:

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


如上遍历数组使用了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. 1 let sectionArray = iosArray[1...4]
  2. 2 print(sectionArray)
  3. 3 输出:
  4. 4 ? 4 elements
  5. 5 - 0 : "O"
  6. 6 - 1 : "V"
  7. 7 - 2 : "E"
  8. 8 - 3 : "I"
复制代码
  1. <br>拓展2:0...6的形式还可以用来初始化创建数组,代码如下:
复制代码
  1. 1 let numbers = Array(1...7)
  2. 2 print(numbers)
  3. 3 输出:
  4. 4 ? 7 elements
  5. 5 - 0 : 1
  6. 6 - 1 : 2
  7. 7 - 2 : 3
  8. 8 - 3 : 4
  9. 9 - 4 : 5
  10. 10 - 5 : 6
  11. 11 - 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. 1 //将字典的kyes转换成数组 2 let keys = Array(iosDict.keys) 3 print(keys[0])
复制代码

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

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

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

反向遍历

  1. 1 //倒序遍历数组
  2. 2 for index in (0...6).reversed() {
  3. 3 print(iosArray[index])
  4. 4 }
  5. 5
  6. 6 for element in iosArray.reversed() {
  7. 7 print(element)
  8. 8 }
  9. 9
  10. 10 //倒序遍历字典
  11. 11 for (key, value) in iosDict.reversed() {
  12. 12 print("\(key): \(value)")
  13. 13 }
复制代码
  1. <strong style="font-family: "PingFang SC", "Helvetica Neue", Helvetica, Arial, sans-serif; font-size: 14px"><em>1、</em></strong>如上无论是0...6这种索引方式还是快速遍历,都可直接调用reversed()函数轻松实现反向遍历。
复制代码

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

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

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

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

forEach遍历

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

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

注意: 1、不能使用“break”或者“continue”退出遍历; 2、使用“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. <br>
复制代码
  1. 1 //stride正向遍历
  2. 2 for index in stride(from: 1, to: 6, by: 1) {
  3. 3 print(index)
  4. 4 print(iosArray[index])
  5. 5 }
  6. 6
  7. 7 //stride正向跳跃遍历
  8. 8 for index in stride(from: 0, to: 6, by: 2) {
  9. 9 print(index)
  10. 10 print(iosArray[index])
  11. 11 }
  12. 12
  13. 13 //stride反向遍历
  14. 14 for index in stride(from: 6, to: 1, by: -1) {
  15. 15 print(index)
  16. 16 print(iosArray[index])
  17. 17 }
  18. 18
  19. 19 //stride through正向遍历
  20. 20 for index in stride(from: 0, through: 6, by: 1) {
  21. 21 print(index)
  22. 22 print(iosArray[index])
  23. 23 }
复制代码
  1. <strong style="font-family: "PingFang SC", "Helvetica Neue", Helvetica, Arial, sans-serif; font-size: 14px"><em>1、</em></strong>
复制代码

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

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

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

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

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

正向遍历

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

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


反向遍历

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

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



回复

使用道具 举报