OC：Block语法、Block使用、Block实现数组排序

Block

//定义一个求两个数最大值函数

int maxValue (int ,int);

//函数的实现

int maxValue (int a, int b){

return  a > b ? a : b;

}

//函数指针 （调用可以用 p 或者 maxValue）

int (* p)(int,int) = maxValue;

int max =  p(24, 48);

block是一个匿名函数，也是一个函数，只不过没有名字而已。也叫语法块。

把函数名去掉剩余的部分就是函数类型。

对于Block 的定义：

函数的返回值类型 （^ block 变量名）（参数列表）= ^ 返回值类型（可以省略）（参数列标（形参名不可以省略））{

}；

Block 的类型 ：int (^)(int ,int)      //就是把变量名去掉后的部分

Block 的变量名：

//定义一个无参数无返回值的 block

//无参数时，小括号不能省去

void (^ sayHi)() = ^void(){

NSLog(@"hellow");

};

sayHi();

//有参数无返回值的block

void (^ sayHi1)(int a) = ^ (int a){//block的定义

NSLog(@"%d",a);

};

sayHi1(5);//block的调用

//定义一个block 实现把数字字符串转化为整数

int (^ exchangeCagrToInt)(NSString *) = ^ int(NSString * array){

int n = [array intValue];

return n;

};

//OC对象作为参数使用

int c = exchangeCagrToInt(@"13");//如果写的是 123ABC 只会打印123  如果是 abc A 之类的就会打印出0，所以以后使用的时候要注意

NSLog(@"%d",c);

//对比C语言的函数指针

//对block 进行重命名（是给block变量类型重名名）

typedef int (^ ValueOfTwo)(int,int);

//ValueOfTwo 指向 返回值为 int 有两个 int 参数的 bloc 类型的 block

ValueOfTwo newBlock = ^(int a ,int b){//此时  newBlock 求两个数的和

return a + b;

};

//注意

int number = 20;

void (^myblock)(int ) = ^(int num){

NSLog(@"%d",num);

NSLog(@"%d",number);

//number 赋新值

//number = number - num;//这里会报错，因为在block内部不能修改局部变量的值，但是可以访问局部变量的值

};

myblock(10);

__block int number = 20;//这样让block内部可以改变我们定义的局部变量

void (^myblock)(int ) = ^(int num){

NSLog(@"%d",num);

NSLog(@"%d",number);

//number 赋新值

number = number - num;//这里不报错，因为在局部变量的值前面加上了修饰符 “__block” 注意是两个下划线哦，但是可以访问局部变量的值

};

myblock(10);

//我们称 ^ 为 托字符

 //
 //  main.m
 #import <Foundation/Foundation.h>

 //定义一个求两个数最大值函数
 int maxValue (int ,int);
 //函数的实现
 int maxValue (int a, int b){
     return  a > b ? a : b;
 }
 int main(int argc, const char * argv[]) {
     @autoreleasepool {
         // insert code here...
         NSLog(@"Hello, World!");
         //函数指针 （调用可以用 p 或者 maxValue）
         int (* p)(int,int) = maxValue;
         int max =  p(, );
         //Block：匿名函数 也是一种函数  只不过是特殊的函数（匿名函数）
         /*
          对于Block 的定义：
          函数的返回值类型 （^ block 变量名）（参数列表）= ^ 返回值类型（可以省略）（参数列标（形参名不可以省略））{
          }；
          */
 //        int (^ maxOfTwo)(int, int) = ^ int(int a,int b){
 //            return a > b ? a :b;
 //        };
         int (^ maxOfTwo)(int, int) = ^ (int a,int b){
             return a > b ? a :b;
         };
         /*
          Block 的类型 ：int (^)(int ,int)      //就是把变量名去掉后的部分
          Block 的变量名：
          */
         int result = maxOfTwo (,);
         NSLog(@"%d",result);
         int (^ mutil)(int ,int) = ^int (int a,int b){
             return a*b;
         };
         int ji = mutil( ,);
         NSLog(@"%d",ji);
         //定义一个无参数无返回值的 block
         //无参数时，小括号不能省去
         void (^ sayHi)() = ^void(){
             NSLog(@"hellow");
         };
         sayHi();
         //有参数无返回值的block
         void (^ sayHi1)(int a) = ^ (int a){
             NSLog(@"%d",a);
         };
         sayHi1();
         //block的定义
         void (^ printNum)(int a) = ^ void (int a){
             NSLog(@"%d",a);
         };
         //block的调用
         printNum();

         //定义一个block 实现把数字字符串转化为整数
         int (^ exchangeCagrToInt)(NSString *) = ^ int(NSString * array){
             int n = [array intValue];
             return n;
         };
         int c = exchangeCagrToInt(@"13的是否合格");
         NSLog(@"%d",c);
         //对比C语言的函数指针
         //对block 进行重命名（是给block变量类型重名名）
         typedef int (^ ValueOfTwo)(int,int);
         //ValueOfTwo 指向 返回值为 int 有两个 int 参数的 bloc 类型的 block
         ValueOfTwo newBlock = ^(int a ,int b){
             return a + b;
         };//此时  newBlock 求两个数的和
         int bb = newBlock(,);
         NSLog(@"%d",bb);
         ValueOfTwo newMulBlock = ^(int a,int b){
             return a*b;
         };
         int bc = newMulBlock(,);
         NSLog(@"%d",bc);

         //block访问外面定义的局部变量
         __block int number = ;
         void (^myblock)(int ) = ^(int num){
             NSLog(@"%d",num);
             NSLog(@"%d",number);
             //number 赋新值
             number = number - num;//这里不报错，因为在局部变量的值前面加上了修饰符 “__block” 注意是两个下划线哦，但是可以访问局部变量的值

         };
         myblock();
     }
     return ;
 }

block定义

// __block 的作用就是在block 块内部使函数的局部变量不仅可以被访问，而且还可以被修改（保护局部变量可以在函数的其他地方被访问和做修改，不影响其他地方的对局部变量的操作）

//在全局的外面定义的变量就是全局变量（我们在main 函数外面声明一个）

int openValue = 12;//在函数内与函数外都可被访问

__block int number = 20;

void (^myblock)(int ) = ^(int num){

openValue ++;//全局变量不仅可以直接访问而且还可以直接被修改

NSLog(@"%d",num);

NSLog(@"%d",number);

//number 赋新值

number = number - num;//这里不报错，因为在局部变量的值前面加上了修饰符 “__block” 注意是两个下划线哦，但是可以访问局部变量的值

};

myblock(10);

  // __block 的作用就是在block 块内部使函数的局部变量不仅可以被访问，而且还可以被修改（保护局部变量可以在函数的其他地方被访问和做修改，不影响其他地方的对局部变量的操作）
         //练习 ：把数组中的字符串拼接成一个字符串
 //        NSArray * stsArr = [NSArray arrayWithObjects:@"Hello",@"Hello",@"39", nil];
         NSArray * strArr = @[@"Hello",@"hhhh",@""];
         NSString * (^appendString)(NSArray *) = ^(NSArray * arr){
             NSString * newStr = @"";//这里不能写成：NSString * newStr = nil;
             for (int i =  ; i < [arr count]; i++) {
                 NSString * append = arr[i];//获取数组中每个字符串对象
                 newStr = [newStr stringByAppendingString:append];//拼接功能,注意使用 newStr 去接受
             }
             return newStr;
         };
         NSString * afterAppendSting = appendString(@[@"",@"",@"",@""]);
         NSLog(@"%@",afterAppendSting);
     }

字符串拼接

 //比较两个字符串的大小
         NSString * str1 = @"";
         NSString * str2 = @"";
 //        BOOL (^ compareStrings)(NSString *,NSString *) = ^(NSString * str01,NSString * str02){
 //            NSComparisonResult result = [str01 compare:str02];
 //            return result;
 //        };//这种写法是错误的

         NSComparisonResult (^ compareStrings)(NSString *,NSString *) = ^(NSString * str01,NSString * str02){
             NSComparisonResult result = [str01 compare:str02];
             return result;
         };
         NSComparisonResult resu = compareStrings(str1,str2);
         if (resu >= ) {
             NSLog(@"str1大于str2");
         }
         if (resu == ) {
             NSLog(@"str1 str2相等");
         }
         if (resu < ) {
             NSLog(@"str1小于str2");
         }

字符串比较代码1

 //第二节代码
         // __block 的作用就是在block 块内部使函数的局部变量不仅可以被访问，而且还可以被修改（保护局部变量可以在函数的其他地方被访问和做修改，不影响其他地方的对局部变量的操作）
         //练习 ：把数组中的字符串拼接成一个字符串
 //        NSArray * stsArr = [NSArray arrayWithObjects:@"Hello",@"Hello",@"39", nil];
         NSArray * strArr = @[@"Hello",@"HH",@""];
         NSString * (^appendString)(NSArray *) = ^(NSArray * arr){
             NSString * newStr = @"";//这里不能写成：NSString * newStr = nil;
             for (int i =  ; i < [arr count]; i++) {
                 NSString * append = arr[i];//获取数组中每个字符串对象
                 newStr = [newStr stringByAppendingString:append];//拼接功能,注意使用 newStr 去接受
             }
             return newStr;
         };
         NSString * afterAppendSting = appendString(@[@"",@"",@"",@""]);
         NSLog(@"%@",afterAppendSting);

         //比较两个字符串的大小
         NSString * str1 = @"";
         NSString * str2 = @"";
 //        BOOL (^ compareStrings)(NSString *,NSString *) = ^(NSString * str01,NSString * str02){
 //            NSComparisonResult result = [str01 compare:str02];
 //            return result;
 //        };//这种写法是错误的

         NSComparisonResult (^ compareStrings)(NSString *,NSString *) = ^(NSString * str01,NSString * str02){
             NSComparisonResult result = [str01 compare:str02];//得到枚举的结果
             //在内部判断可以不用返回值
             if (result == NSOrderedAscending) {//升序
                 NSLog(@"str1小于str2");
             }
             if (result == NSOrderedDescending) {//降序
                 NSLog(@"str1大于str2");
             }
             if (result == NSOrderedSame) {//相等
                 NSLog(@"str1 str2相等");
             }
             //也可以使用分支
             switch (result) {
                 case NSOrderedAscending:
                      NSLog(@"str1小于str2");
                     break;
                 case NSOrderedDescending:
                      NSLog(@"str1大于str2");
                     break;
                 case NSOrderedSame:
                      NSLog(@"str1 str2相等");
                     break;
                 default:
                     break;
             }

             return result;
         };

         NSComparisonResult resu = compareStrings(str1,str2);//比较的方法通过返回值在外部判断
         if (resu >= ) {
             NSLog(@"str1大于str2");
         }
         if (resu == ) {
             NSLog(@"str1 str2相等");
         }
         if (resu < ) {
             NSLog(@"str1小于str2");
         }
         if (resu == NSOrderedAscending) {//升序
             NSLog(@"str1小于str2");
         }
         if (resu == NSOrderedDescending) {//降序
             NSLog(@"str1大于str2");
         }
         if (resu == NSOrderedSame) {//相等
             NSLog(@"str1 str2相等");
         }

字符串比较代码2

===================== =====================

说明上面  字符串比较代码1  里面错误的代码是因为

NSComparisonResult 有三个返回值（0，-1，1）  而bool只有两种情况 0 与 非0

===================== =====================

NSComparisonResult result = [str1  compare: str2];  // result 的返回值（值的形式很灵活）要 注意

result有下面三种值

NSOrderedAscending://-1等价

NSOrderedDescending://1等价

NSOrderedSame://0等价

 //
 //  main.m
 #import <Foundation/Foundation.h>
 #import "Person.h"
 #import "DownLoadManager.h"
 #import "LoginManage.h"

 int main(int argc, const char * argv[]) {
     @autoreleasepool {
         // insert code here...
         NSLog(@"Hello, World!");
         //block练习 定义block 比较两个整数的大小
         void (^ compareTwoNum)(int a ,int b) = ^(int a, int b){
             if (a > b) {
                 NSLog(@"%d 大于 %d",a,b);
             }
             if (a < b) {
                 NSLog(@"%d 小于 %d",a,b);
             }
             else{
                 NSLog(@"%d 等于 %d",a,b);
             }
         };
         compareTwoNum(,);
         //compare 是OC提供的比较的对象方法
         //把=左边的block名字去掉就是block的类型
         NSComparisonResult(^numCompare)(NSInteger,NSInteger) = ^(NSInteger a, NSInteger b){
             //数字的对象是 NSnumber
             NSNumber * object1 = [NSNumber numberWithInteger:a];
             NSNumber * object2 = [NSNumber numberWithInteger:b];
             //笑笑语法
             NSNumber * obj1 = @(a);//如果是数字的话 直接 @123 （@数字）
             NSNumber * obj2 = @(b);
             return [object1 compare:object2];
         };
          NSComparisonResult cmpResult = numCompare(,);
         //NSComparisonResult 是一个枚举类型既不是指针，也不是变量 （1 对应降序） （-1 对应的升序） （0 对应的是相等）
         //返回值类型根据需求而定
         NSLog(@"%ld",cmpResult);

         //不可变数组
         //（将block作为方法的参数）
         NSArray *arr = [NSArray arrayWithObjects:@"how",@"hai",@"what", nil];
         // NSArray * arr = @[@"hai",@"how",@"what"];
         //排序 记住排序的首字母是 Sort开头
         //sortedArrayUsingSelector 默认是升序排序 返回的是一个不可变的数组 可变是不可变的子类
         NSArray * newArr = [arr sortedArrayUsingSelector:@selector(compare:)];//相当于把原来的排好序然后拷贝一份给newArr
         NSLog(@"%@",newArr);

         //不可变数组两种排序
     //^NSComparisonResult(id obj1, id obj2) 这个block 作为一个参数
      /*  参数为 :^NSComparisonResult(id obj1, id obj2) {
         return [obj1 compare:obj2];
     }*/
         //下面的方法系统默认的是升序的
        NSArray * newArray = [arr sortedArrayUsingComparator:^NSComparisonResult(id obj1, id obj2) {
              return [obj1 compare:obj2];//这是返回的block方法执行后的值
            //而数组调用的sortedArrayUsingComparator方法返回一个排好序的数组
        //  return -[obj1 compare:obj2];//改变默认的排序为降序排序
        //  return [obj2 compare:obj1];//改变默认的排序为降序排序
         }];
         NSLog(@"--用Block作为参数排序--%@",newArray);

         //可变数组的排序
         NSMutableArray * mutArr = [NSMutableArray arrayWithArray:arr];
         NSMutableArray * mutArr1 = [@[@"",@"",@"",@"",]mutableCopy];//把不可变的数组转变为可变数组
         //也可以用  arrayWithArray 吧不可变数组转变为可变数组
         //排序 （排序方法名以 sort 开头）
 //        mutArr1  sortedArrayUsingDescriptors:<#(NSArray *)#>
         //可变数组的排序方法
         [mutArr1  sortUsingSelector:@selector(compare:)];
         NSLog(@"普通方法：%@",mutArr1);
         /*可变数组排序默认为升序
         mutArr1 sortUsingComparator:^NSComparisonResult(id obj1, id obj2) {
             <#code#>
         }*/
         [mutArr1 sortUsingComparator:^NSComparisonResult(id obj1, id obj2) {
             NSLog(@"%@ %@",obj1,obj2);//打印观看内部比较规则
             return [obj1 compare:obj2];//默认升序
         }];
         NSLog(@"用block方法：%@",mutArr1);

         //创建一个数组存放 5 个 person 类的对象
         Person * per1 = [[Person alloc]initWithName:@"niujianwei" age: height:1.75];
         Person * per2 = [[Person alloc]initWithName:@"zhangjian" age: height:1.75];
         Person * per3 = [[Person alloc]initWithName:@"huangtuan" age: height:1.80];
         Person * per4 = [[Person alloc]initWithName:@"zhangping" age: height:1.67];
         Person * per5 = [[Person alloc]initWithName:@"zhanghua" age: height:1.70];
         NSArray * perArr = [NSArray arrayWithObjects:per1,per2,per3,per4,per5, nil];
         // NSArray * perArr2 = @[per1,per2,per3,per4,per5];
         // NSMutableArray * arrayPers = [@[@"per1",@"per2",@"per3",@"per4",@"per5"]mutableCopy];是错误的存放方法，因为人不要打“”，打了之后就是一个字符串了
 //        NSArray * newarr =  [perArr sortedArrayUsingSelector:@selector(compare:)];
 //        NSLog(@"对五个人排序后为%@",newarr);//这里是对象在比较不可以
         NSArray * newPerArr = [perArr sortedArrayUsingComparator:^NSComparisonResult(id obj1, id obj2) {
 //            Person * per1 = obj1;
 //            Person * per2 = obj2;//转化之后直接拿 per1 与 per2 比较
            return [[obj1 name]compare:[obj2 name]];
 //            obj1 = (Person *)per1;//或者吧id改为 Person
 //            return [obj1 compare:obj2];
         }];
         NSLog(@"%@",newPerArr);
         //按年龄的降序排序
         NSArray * newByageDes = [perArr sortedArrayUsingComparator:^NSComparisonResult(id obj1, id obj2) {
             return [@([obj2 age]) compare:@([obj1 age])];
         }];
         NSLog(@"按年龄的降序排序%@",newByageDes);

         //按身高排序
         NSArray * newByHeight = [perArr sortedArrayUsingComparator:^NSComparisonResult(id obj1, id obj2) {
             return  -[@([obj1 height]) compare:@([obj2 height])];
         }];
         NSLog(@"按身高的降序排序%@",newByHeight);

         //如果那个compare：不能满足的话，那就自己写方法
         // NSArray * newByHeight2 = [perArr sortedArrayUsingSelector:@selector(compare:)];
         //block 传值 （下载：一首歌从下载的页面传过来，从一个页面吧下载的字节，下载了多少的值传过来）
         DownLoadManager * manger = [[DownLoadManager alloc]init];
         [manger download:^(int n) {
             NSLog(@"%d",n);
         }];

         [manger chuanzhi:^(int n, int b) {
           NSLog(@"%d %d",n,b);
         }];

         LoginManage * login = [[LoginManage alloc]init];
         //block类型中的返回值把外部的值传到里面
         [login loginWihtName:@"user" password:@"" success:^(NSString *accountName) {
             NSLog(@"%@",accountName);
         } failure:^BOOL(NSString *errorMessage) {
             NSLog(@"%@",errorMessage);
             return ;//把外面的值传到里面
         }];

     }
     return ;
 }

main.m文件

 //
 //  Person.h
 #import <Foundation/Foundation.h>

 @interface Person : NSObject
 {
     NSString *_name;
     NSInteger _age;
     CGFloat  _height;
 }
 //setter getter
 - (void)setName:(NSString *)name;
 - (NSString *)name;
 - (void)setAge:(NSInteger)age;
 - (NSInteger)age;
 - (void)setHeight:(CGFloat)height;
 - (CGFloat)height;
 //初始化
 - (id)initWithName:(NSString *)name
                age:(NSInteger)age
             height:(CGFloat)height;
 //便利构造器
 + (Person *)personWithNmae:(NSString *)name
                        age:(NSInteger)age
                     height:(CGFloat)height;
 - (NSString *)description;
 @end

Persoon.h文件

 //
 //  Person.m
 #import "Person.h"

 @implementation Person
 //setter getter
 - (void)setName:(NSString *)name{
     _name = name;
 }
 - (NSString *)name{
     return  _name;
 }
 - (void)setAge:(NSInteger)age{
     _age = age;
 }
 - (NSInteger)age{
     return _age;
 }
 - (void)setHeight:(CGFloat)height{
     _height = height;
 }
 - (CGFloat)height{
     return _height;
 }
 //初始化
 - (id)initWithName:(NSString *)name
                age:(NSInteger)age
             height:(CGFloat)height{
     self = [super init];
     if (self) {
         _name = name;
         _age = age;
         _height = height;
     }
     return self;
 }
 //便利构造器
 + (Person *)personWithNmae:(NSString *)name
                        age:(NSInteger)age
                     height:(CGFloat)height{
     Person * per = [[Person alloc]initWithName:name age:age height:height];
     return per;
 }
 - (NSString *)description{
     return [NSString stringWithFormat:@"name: %@ age: %ld height: %.2f",_name,_age,_height];
 }
 @end

Person.m文件

 //
 //  DownLoadManager.h
 #import <Foundation/Foundation.h>

 typedef void (^myBlock)(int n);
 typedef void (^myBlock1)(int n,int b);
 @interface DownLoadManager : NSObject
 {

 }
 - (void)download:(myBlock)block;
 - (void)chuanzhi:(myBlock1)block1;

 //登陆场景

 @end

DownLoadManager.h文件

 //
 //  DownLoadManager.m
 #import "DownLoadManager.h"

 //block类型的参数适用于回调时从里面把数据传到外面（传值的作用）
 //把数据从一个类里面(当前这个类)传到另一个类里面（外面需要使用的地方）
 @implementation DownLoadManager

 - (void)download:(myBlock)block{
     //block 使用场景
     NSLog(@"与服务器建立连接");
     NSLog(@"开始下载");
     //模拟下载字节数
     int byte = ;
     for (int i = ; i < ; i++) {
         byte = arc4random() % ;
 //        NSLog(@"下载%d",byte);
     }
     int ddd = ;
     //把数据传到外部
     NSLog(@"开始传值");
     block(ddd);
 }

 - (void)chuanzhi:(myBlock1)block1{
     int bb = ;
     int c = ;
     block1(bb,c);
 }

 //登陆

 @end

DownLoadManager.m文件

 //
 //  LoginManage.h
 #import <Foundation/Foundation.h>

 typedef  void (^successfulBlock) (NSString *accountName);//对于登陆成功
 typedef BOOL (^failureBlock)(NSString *errorMessage);//失败的情况
 @interface LoginManage : NSObject
 {

 }
 -(void)loginWihtName:(NSString *)name
             password:(NSString *)password
              success:(successfulBlock)success
              failure:(failureBlock)failure;
 @end

LoginManage.h文件

 //
 //  LoginManage.m
 #import "LoginManage.h"

 @implementation LoginManage
 -(void)loginWihtName:(NSString *)name
             password:(NSString *)password
              success:(successfulBlock)success
              failure:(failureBlock)failure{
     //block类型中的返回值把外部的值传到里面
     if ([name isEqualToString:@"user"]&& [password isEqualToString:@""]) {
         NSLog(@"登陆成功");
         //回调并传递信息
         success (name);//把name 传出去
     }else{
         //我们从外部得到的返回值给 result
        BOOL result  = failure(@"账户或密码错误！");
         if (result) {
             NSLog(@"错误已经处理");
         }
         else{
             NSLog(@"错误没有处理");
         }
     }
 }
 @end

LoginManage.m文件

=====实战=====

1.定义一个Block，返回值为bool,有两个NSString 实现判断两个字符串是否相等。

2.创建一个数组，初始化为@“123”，@“21”，@“33”，@“69”，@“108”，@“256”使用Block，进行数组排序，并输出内容

3.定义一个Block，返回值为NSInteger ,有两个参数，一个是NSArray 一个是NSString，实现判断数组时候包含此字符串，如果包含，返回字符串下标，如果不包含返回-1.

 //
 //  main.m
 #import <Foundation/Foundation.h>

 int main(int argc, const char * argv[]) {
     @autoreleasepool {
 //        1.定义一个Block，返回值为bool,有两个NSString 实现判断两个字符串是否相等。
 //
 //        2.创建一个数组，初始化为@“123”，@“21”，@“33”，@“69”，@“108”，@“256”使用Block，进行数组排序，并输出内容
 //
 //        3.定义一个Block，返回值为NSInteger ,有两个参数，一个是NSArray 一个是NSString，实现判断数组时候包含此字符串，如果包含，返回字符串下标，如果不包含返回-1.
         printf("输入两个字符串\n");
         char str[][] = {};
         NSMutableArray * arrr = [NSMutableArray array];
         for (int i = ; i < ; i++) {
             scanf("%s",str[i]);
             arrr[i] = [[NSString alloc]initWithUTF8String:str[i]];
         }
         BOOL (^isEqualTwoString)(NSString *,NSString *) = ^(NSString * str1 ,NSString *str2){
             return [str1 isEqualToString:str2];
         };
         int i = isEqualTwoString(arrr[],arrr[]);
         if (i) {
             NSLog(@"相等");
         }else{
             NSLog(@"不相等");
         }

         //第二题
         NSArray * arr = @[@"",@"",@"",@"",@"",@""];
         printf("选择排序方法（1，2，3）");
         int chose = ;
         scanf("%d",&chose);
         switch (chose) {
             case :
             {
                 NSArray * newArr = [arr sortedArrayUsingSelector:@selector(compare:)];
                 NSLog(@"%@",newArr);
             }
                 break;
             case :
             {
                 NSArray * newArr1 = [arr sortedArrayUsingComparator:^NSComparisonResult(id obj1, id obj2) {
                     return [obj1 compare:obj2];
                 }];

                 NSLog(@"%@",newArr1);
             }
                 break;
             case :
             {
                 NSArray * newArr2 = [arr sortedArrayWithOptions:(NSSortOptions) usingComparator:^NSComparisonResult(id obj1, id obj2) {
                    return [obj1 compare:obj2];
                 }];
                 NSLog(@"%@",newArr2);
             }
                 break;

             default:
                 NSLog(@"输入错误");
                 break;
         }

         //第三题
         NSInteger (^ workForArrAndStr) (NSArray * ,NSString *) = ^(NSArray * arr1,NSString * str1){
             NSInteger i = ;
             for (NSString * object in arr1) {
                 i++;
                 if (object == str1) {
                     return i;
                     break;
                 }
             }
             NSInteger b = -;
             return b;
         };
         NSArray * array = @[@"hello",@"HHH",@"heman",@"china",@"nanyang"];
         NSString * string = @"hello";
         NSInteger n = workForArrAndStr(array,string);
         if (n == -) {
             NSLog(@"没有找到");
         }else{
             NSLog(@"所在下标为：%lu",n - );
         }
     }
     return ;
 }

简单排序代码

参考

- (NSArray *)sortedArrayWithOptions:(NSSortOptions)opts usingComparator:(NSComparator)cmptr

opts 为0或1 是指定排序的某个条件（是否并发和稳定）。

根据我的测试，数组里有65000个元素进行排序，

opts 为1 明显要比opts 为0 快得多。
(NSComparator)cmptr 这个就是排序

===========

1.compare在使用的时候是对OC里面对象的比较要是比较 NSinterger 的两个数字，需要转换为 NSNumber ，转化方法为：NSinterger b =100; NSNumber * bb = @(b);也可以  NSNumber * bb = @100;数字的话直接 @数字

2.NSComparisonResult 是一个枚举类型既不是指针，也不是变量 （1 对应降序） （-1 对应的升序） （0 对应的是相等）他的值只有这三个

3.block 作为参数的理解

//不可变数组两种排序

//^NSComparisonResult(id obj1, id obj2) 这个block 作为一个参数

/*  参数为 :^NSComparisonResult(id obj1, id obj2) {

return [obj1 compare:obj2];

}*/

//下面的方法系统默认的是升序的

NSArray * newArray = [arr sortedArrayUsingComparator:^NSComparisonResult(id obj1, id obj2) {

return [obj1 compare:obj2];//这是返回的block方法执行后的值

//而数组调用的sortedArrayUsingComparator方法返回一个排好序的数组

//  return -[obj1 compare:obj2];//改变默认的排序为降序排序（注意前面加了一个 -号，默认为升序加一个 负号就是降序）

//  return [obj2 compare:obj1];//改变默认的排序为降序排序

}];

NSLog(@"--用Block作为参数排序--%@",newArray);

4.在有compare比较后的函数的返回值  可用  NSComparisonResult

5.注意在创建好Person的对象之后在添加到数组的时候，不要忘了，添加的是person对象，不能写成字符串

（错误例子：NSMutableArray * arrayPers = [@[@"per1",@"per2",@"per3",@"per4",@"per5"]mutableCopy];）

6.Block使用的时候可以当做参数，（注意与函数的回调相联系）

 一、概述
 Block是C级别的语法和运行时特性。Block比较类似C函数，但是Block比之C函数，其灵活性体现在栈内存、堆内存的引用，我们甚至可以将一个Block作为参数传给其他的函数或者Block。

 二、热身
 先看一个比较简单的Block例子：

 int multiplier = ;
 int (^myBlock)(int) = ^(int num) {
     return num * multiplier;
 };
 在这个例子中，myBlock是一个Block变量，它接受一个int类型的参数，返回一个int类型的值。是不是很像C函数？

 来，让我们typedef一下

 typedef void (^BoolBlock)(BOOL);//一个只接受一个BOOL参数，没有返回值的block
 typedef int (^IntBlock)(void);//一个没有参数，返回int的block
 typedef BoolBlock (^HugeBlock)(IntBlock);//看看，这个HugeBlock的参数和返回值都是block
 三、更详细的例子
 注意：上面的typedef都还有效~

 主动调用一下：

 - (void)someMethod
 {
     BoolBlock ablock = ^(BOOL bValue) {
         NSLog(@"Bool block!");
     };
     ablock();
 }
 作为参数返回：

 typedef void (^BoolBlock)(BOOL);
 - (BoolBlock)foo()
 {
     BoolBlock ablock = ^(BOOL bValue) {
         NSLog(@"Bool block!");
     };
     return [[ablock copy] autorelease];//一定要copy，将其复制到堆上，更详细的原理，将在后续章节讲解
 }
 类的一个成员：

 @interface OBJ1 : NSObject
 @property (nonatomic, copy)BoolBlock block;//理由同上啊，同学们
 @end 

 OBJ1 *obj1 = ...
 obj1.block = ^(BOOL bValue) {
         NSLog(@"Bool block!");
     };
 其他函数的参数：

 - (void)foo(BoolBlock block)
 {
     if (block) {
         block();
     }
 }
 甚至其他block的参数：

 BoolBlock bBlock = ^(BOOL bV){if(Bv){/*do some thing*/}};
 HugeBlock hBlock = ^(BoolBlock bB) {bB();}; 

 hBolck(bBlock);
 啊，全局变量！：

 static int(^maxIntBlock)(int, int) = ^(int a, int b){return a>b?a:b;};
 int main()
 {
     printf("%d\n", maxIntBlock(,));
     return ;
 }
 好了，你知道block大概能怎么用了。

 四，特殊的标记，__block
 如果要在block内修改block外声明的栈变量，那么一定要对该变量加__block标记：

 int main()
 {
     __block int i = ;
     BoolBlock bBlock = ^(BOOL bV) {
         if (bV) {
             i++;//如果没有__block标记，是无法通过编译的。
         }
     };
 } 

Block 使用（来自互联网）

参考1  参考2