2016-04-08 16:36:23 yishengzhiai005 阅读数 3630

Swift的NSArray一经初始化数据可变但是不能在原有基础上添加新数据

废话不多说

        var na:NSArray = ["Pencil","Eraser", "Notebkko"]

       println(na.count)//Pencil、Eraser、Notebkko


        var na:NSArray = ["Pencil","Eraser", "Notebkko"]

       var nb:NSArray = ["a","b","c"];

        na=nb

       println(na.count)//3 此时的na里的值为 abc


*祝不能在原有基础上添加第四个元素

如果添加用NSMutableArray

        var nn:NSMutableArray = ["a","c"]

        nn.addObject("b")

println(nn.count)//输出为acb
2015-05-12 14:52:20 wei78008023 阅读数 6050

一、遍历

1.for循环遍历

NSArray *array = [NSArray arrayWithObjects:stu1, @"1", @"2", @"3", nil];
int count = array.count;
for (int i = 0; i<count; i++) 
{
    id obj = [array objectAtIndex:i];
}

2.快速遍历

    Student *stu1 = [Student student];
    NSArray *array = [NSArray arrayWithObjects:stu1, @"1", @"2", @"3", nil];
    int i =0;
    for (id obj in array) 
    {
        NSLog(@"%d-%@", i, obj);
        i++;
    }

3.代码块遍历

    Student *stu1 = [Student student];
    NSArray *array = [NSArray arrayWithObjects:stu1, @"1", @"2", @"3", nil];
    [array enumerateObjectsUsingBlock:
     ^(id obj, NSUInteger idx, BOOL *stop) {
         NSLog(@"%ld-%@",idx, obj);
         // 如果索引为1,就停止遍历
         if (idx == 1) {
             // 利用指针修改外面BOOL变量的值
             *stop = YES;
         }
     }];

4.迭代器方法遍历

    Student *stu1 = [Student student];
    NSArray *array = [NSArray arrayWithObjects:stu1, @"1", @"2", @"3", nil];
    // 获取数组的迭代器
    // NSEnumerator *enumerator = [array objectEnumerator];
    // 反序迭代器(从尾部开始遍历元素)
    NSEnumerator *enumerator = [array reverseObjectEnumerator];
    // allObjects是取出没有被遍历过的对象
    NSArray *array2 = [enumerator allObjects];
    NSLog(@"array2:%@", array2);
    // 获取下一个需要遍历的元素
    id obj = nil;
    while (obj = [enumerator nextObject]) {
        NSLog(@"obj=%@", obj);
    }

二、排序

以下数组排序中,如果存放的是NSNumber类型的,例如NSArray *array = [NSArray arrayWithObjects:@245, @33, @1456, @4, nil];则会按照转化为常用类型后的大小排序,但是如果存放的是字符串,例如NSArray *array = [NSArray arrayWithObjects:@"245", @"33", @"1456", @"4", nil];则会先按照第一位大小排序,第一位大小相同的,会按照第二位大小再排,以此类推,下面就简单以字符串为代表罗列以下

1.普通排序

    NSArray *array = [NSArray arrayWithObjects:@"2", @"3", @"1", @"4", nil];
    // 返回一个排好序的数组,原来数组的元素顺序不会改变
    // 指定元素的比较方法:compare:
    NSArray *array2 = [array sortedArrayUsingSelector:@selector(compare:)];
    NSLog(@"array2:%@", array2);

下面的排序需要用到自定义的类型,我们就自定义一个dataaaaa类,添加属性和方法

@property (strong,nonatomic) NSString *money;
@property (strong,nonatomic) NSString *count;

@property (strong,nonatomic) NSNumber *moneyN;
@property (strong,nonatomic) NSNumber *countN;

- (NSComparisonResult)comparedata1:(dataaaaa *)aaa;
- (NSComparisonResult)comparedata2:(dataaaaa *)aaa;

之后在需要排序的地方实例化一个存存放该数据类型的数组

    dataaaaa *a1=[[dataaaaa alloc]init];
    a1.money=@"5";
    a1.count=@"435";
    a1.moneyN=@5;
    a1.countN=@435;
    dataaaaa *a2=[[dataaaaa alloc]init];
    a2.money=@"480";
    a2.count=@"23";
    a2.moneyN=@480;
    a2.countN=@23;
    dataaaaa *a3=[[dataaaaa alloc]init];
    a3.money=@"135";
    a3.count=@"2335";
    a3.moneyN=@135;
    a3.countN=@2335;
    dataaaaa *a4=[[dataaaaa alloc]init];
    a4.money=@"135";
    a4.count=@"17";
    a4.moneyN=@135;
    a4.countN=@17;
NSArray *array = [NSArray arrayWithObjects:a1,a2,a3, a4, nil];
2.自定义排序方法
    // 指定排序的比较方法
    //NSArray *array2 = [array sortedArrayUsingSelector:@selector(comparedata1:)];
    NSArray *array2 = [array sortedArrayUsingSelector:@selector(comparedata2:)];
    for (dataaaaa *aaa in array2)
    {
        NSLog(@"aaa.money==%@  aaa.count==%@",aaa.money,aaa.count);
    }
其中comparedata1:和comparedata2:方法的实现和声明是在dataaaa类中实现的
- (NSComparisonResult)comparedata1:(dataaaaa *)aaa
{
    // 先按照姓排序
    NSComparisonResult result = [self.money compare:aaa.money];
    // 如果有相同的姓,就比较名字
    if (result == NSOrderedSame) {
        result = [self.count compare:aaa.count];
    }
    return result;
}

- (NSComparisonResult)comparedata2:(dataaaaa *)aaa
{
    // 先按照姓排序
    NSComparisonResult result = [self.moneyN compare:aaa.moneyN];
    // 如果有相同的姓,就比较名字
    if (result == NSOrderedSame) {
        result = [self.countN compare:aaa.countN];
    }
    return result;
}
3.代码块方法排序
    NSArray *array=@[a1,a2,a3,a4];
    NSArray *array2 = [array sortedArrayUsingComparator:
                       ^NSComparisonResult(dataaaaa *obj1, dataaaaa *obj2) {
                           NSComparisonResult result = [obj1.money compare:obj2.money];
                           // 如果有相同的姓,就比较名字
                           if (result == NSOrderedSame) {
                               result = [obj1.count compare:obj2.count];
                           }

                           return result;
                       }];
4.描述法实现排序
    NSArray *array = [NSArray arrayWithObjects:a1,a2,a3,a4,nil];
    // 先按照money进行排序
    // 这里的key写的是@property的名称
    //如果dataaaaa中还有自定义对象databbb,并且需要其字段排序,则可以@"databbb.shuxing",其中shuxing是databbb的@property的名称
    NSSortDescriptor *moneyasc = [NSSortDescriptor sortDescriptorWithKey:@"money" ascending:YES];
    //再按照count进行排序
    NSSortDescriptor *countasc = [NSSortDescriptor sortDescriptorWithKey:@"count" ascending:YES];
    //按顺序添加排序描述器
    NSArray *ascs = [NSArray arrayWithObjects:moneyasc,countasc,nil];
    NSArray *array2 = [array sortedArrayUsingDescriptors:ascs];










2017-06-12 15:22:54 openUrl 阅读数 438

转发出处:Swift循环遍历集合方法总结


概要

2016年2月份我总结过OC循环遍历,文章在此:iOS开发遍历集合(NSArray,NSDictionary、NSSet)方法总结。时隔一年,随着Swift的逐渐完善,自己使用Swift开发的项目经验和知识逐渐积累,是时候总结一下Swift的循环遍历了。
相信Swift一定会给你一些不一样的东西,甚至是惊喜。


Swit-for.jpeg

第一种方式:for-in循环

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

遍历数组和字典:

    //遍历数组
    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的形式还可以取出制定范围的数组中的元素,代码如下:

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

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

    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>,显然不是一个数组。当然我们可以将他们转换成数组,如下:

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

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

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

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

反向遍历

    //倒序遍历数组
    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()函数实际上是返回给我们一个顺序完全颠倒的集合,那么我们就可以利用这个函数得到一个倒序的集合,非常方便,代码如下:

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

forEach遍历

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

    //使用forEach正向遍历
    iosArray.forEach { (word) in
        print(word)
    }

    //使用forEach的反向遍历
    iosArray.reversed().forEach { (word) in
        print(word)
    }

注意:1、不能使用“break”或者“continue”退出遍历;2、使用“return”结束当前循环遍历,这种方式只是结束了当前闭包内的循环遍历,并不会跳过后续代码的调用。


stride遍历

stride遍历分为
stride<T : Strideable>(from start: T, to end: T, by stride: T.Stride)

stride<T : Strideable>(from start: T, through end: T, by stride: T.Stride)
两种遍历方式,代码如下:

    //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: 6through: 6为例,to:<6或者>6through:<=6或者>=6,至于是<还是>取决于是正向遍历还是反向遍历。

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

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

正向遍历

    //遍历数组
    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...的顺序输入,因此不可以代表在字典中的索引。


反向遍历

    //反向遍历数组
    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确是最好时机,你还在等什么?

2016-07-31 20:12:14 chendehao001 阅读数 1291

  • 这两个关键字在 OC 和 Swift 中的用法相同
  • break: 跳出循环, 无论循环保持条件是否还为真都不会再执行循环
  • continue: 跳出本次循环, 如果循环保持条件还为真还会继续执行循环
//OC:
NSArray *arr = @[@1,@3, @5, @7, @8];
for (NSNumber *num in arr) {
    if ([num isEqualTo:@(7)]) {
        NSLog(@"找到幸运数字");
        break;
    }
    NSLog(@"没有找到幸运数字");
}
//输出结果:
//2016-01-06 17:23:07.807 OCTest[4684:1554896] 没有找到幸运数字
//2016-01-06 17:23:07.808 OCTest[4684:1554896] 没有找到幸运数字
//2016-01-06 17:23:07.808 OCTest[4684:1554896] 没有找到幸运数字
//2016-01-06 17:23:07.808 OCTest[4684:1554896] 找到幸运数字

//NSArray *arr = @[@1,@3, @5, @7, @8];
int count = 0;
for (NSNumber *num in arr) {
    if (num.intValue % 2 != 0 ) {
        NSLog(@"不能被2整除");
        continue;
    }
    NSLog(@"能被2整除");
    count++;
}
NSLog(@"count = %d", count);

//输出结果:
//2016-01-06 17:23:48.005 OCTest[4694:1560348] 不能被2整除
//2016-01-06 17:23:48.006 OCTest[4694:1560348] 不能被2整除
//2016-01-06 17:23:48.006 OCTest[4694:1560348] 不能被2整除
//2016-01-06 17:23:48.006 OCTest[4694:1560348] 不能被2整除
//2016-01-06 17:23:48.006 OCTest[4694:1560348] 能被2整除
//2016-01-06 17:23:48.006 OCTest[4694:1560348] count = 1
//Swift:
var arr:Array<Int> = [1, 3, 5, 7, 8]
for num in arr{
    if num == 7
    {
        print("找到幸运数字")
        break
    }
    print("没有找到幸运数字")
}
//输出结果:
//没有找到幸运数字
//没有找到幸运数字
//没有找到幸运数字
//找到幸运数字

var arr1:Array<Int> = [1, 3, 5, 7, 8]
var count:Int = 0
for num in arr1{
    if num % 2 != 0
    {
        print("不能被2整除")
        continue
    }
    print("能被2整除")
    count++  // 推荐些成 i += 1 的形式
}
print("count = \(count)")

//输出结果:
//不能被2整除
//不能被2整除
//不能被2整除
//不能被2整除
//能被2整除
//count = 1
2017-09-01 17:17:00 dgzr3370 阅读数 13

 前言

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

第一种方式:for-in循环

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

遍历数组和字典:

 //遍历数组
 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的形式还可以取出制定范围的数组中的元素,代码如下:

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

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

 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> ,显然不是一个数组。

当然我们可以将他们转换成数组,如下:

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

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

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

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

反向遍历

 //倒序遍历数组
 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()函数实际上是返回给我们一个顺序完全颠倒的集合,那么我们就可以利用这个函数得到一个倒序的集合,非常方便,代码如下:

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

forEach遍历

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

 //使用forEach正向遍历
 iosArray.forEach { (word) in
 print(word)
 }

 //使用forEach的反向遍历
 iosArray.reversed().forEach { (word) in
 print(word)
 }

注意:

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

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

stride遍历

stride遍历分为

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

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

两种遍历方式,代码如下:

 //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是如何使用的。

正向遍历

 //遍历数组
 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...的顺序输入,因此不可以代表在字典中的索引。

反向遍历

 //反向遍历数组
 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确是最好时机,你还在等什么?

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

转载于:https://www.cnblogs.com/yujidewu/p/7464167.html

iOS swift 基础五

阅读数 184

没有更多推荐了,返回首页