Block就像delegate的简化版

 

iOS SDK 4.0开始，Apple引入了block这一特性，而自从block特性诞生之日起，彷佛它就受到了Apple特殊的照顾和青睐。字面上说，block就 是一个代码块，可是它的神奇之处在于在内联(inline)执行的时候(这和C++很像)还能够传递参数。同时block自己也能够被做为参数在方法和函 数间传递，这就给予了block无限的可能。

在平常的coding里绝大时间里开发者会是各类block的使用者，可是当你须要构建一些比较基础的，提供给别人用的类的时候，使用block会 给别人的使用带来不少便利。固然若是你已经厌烦了一直使用delegate模式来编程的话，偶尔转转写一些block，不只能够锻炼思惟，也能让你写的代 码看起来高端洋气一些，并且由于代码跳转变少，因此可读性也会增长。

先来看一个简单的block吧：

// Defining a block variable BOOL (^isInputEven)(int) = ^(int input) { if (input % 2 == 0) { return YES; } else { return NO; } }; 

以上定义了一个block变量，block自己就是一个程序段，所以有返回值有输入参数，这里这个block返回的类型为BOOL。天赋异秉的OC 用了一样不走寻常路的"{% raw %} ^{% endraw %}"符号来表示block定义的开始（就像用减号和加号来定义方法同样），block的名称紧跟在{% raw %} ^{% endraw %}符号以后，这里是isInputEven（也即之后使用inline方式调用该block时所须要的名称）。这段block接受一个int型的参数， 而在等号后面的int input是对这个传入int参数的说明：在该block内，将使用input这个名字来指代传入的int参数。一开始看block的定义和写法时可能会 比较痛苦，可是请谨记它只是把咱们常见的方法实现换了一种写法而已，请以习惯OC中括号发送消息的速度和决心，尽快习惯block的写法吧！

调用这个block的方法就很是简单和直观了，相似调用c函数的方式便可：

// Call similar to a C function call int x = -101; NSLog(@"%d %@ number", x, isInputEven(x) ? @"is an even" : @"is not an even"); 

不出意外的话输出为-101 is not an even number

以上的用法没有什么特别之处，只不过是相似内联函数罢了。可是block的神奇之处在于block外的变量能够无缝地直接在block内部使用，好比这样：

float price = 1.99; float (^finalPrice)(int) = ^(int quantity) { // Notice local variable price is // accessible in the block return quantity * price; }; int orderQuantity = 10; NSLog(@"Ordering %d units, final price is: $%2.2f", orderQuantity, finalPrice(orderQuantity)); 

输出为Ordering 10 units, final price is: $19.90

至关开心啊，block外的price成功地在block内部也能使用了，这意味着内联函数可使用处于同一scope里的局部变量。可是须要注意的是，你不能在block内部改变本地变量的值，好比在{% raw %} ^{% endraw %}{}里写price = 0.99这样的语句的话，你亲爱的compiler必定是会叫的。而更须要注意的是price这样的局部变量的变化是不会体如今block里的！好比接着上面的代码，继续写：

price = .99; NSLog(@"Ordering %d units, final price is: $%2.2f", orderQuantity, finalPrice(orderQuantity)); 

输出仍是Ordering 10 units, final price is: $19.90，这就比较忧伤了，能够理解为在block内的price是readonly的，只在定义block时可以被赋值（补充说明，其实是由于price是value type，block内的price是在申明block时复制了一份到block内，block外面的price不管怎么变化都和block内的price无关了。若是是reference type的话，外部的变化其实是会影响block内的）。

可是若是确实须要传递给block变量值的话，能够考虑下面两种方法：

一、将局部变量声明为__block，表示外部变化将会在block内进行一样操做，好比：

// Use the __block storage modifier to allow changes to 'price' __block float price = 1.99; float (^finalPrice)(int) = ^(int quantity) { return quantity * price; }; int orderQuantity = 10; price = .99; NSLog(@"With block storage modifier - Ordering %d units, final price is: $%2.2f", orderQuantity, finalPrice(orderQuantity)); 

此时输出为With block storage modifier – Ordering 10 units, final price is: $9.90

二、使用实例变量——这个比较没什么好说的，实例内的变量横行于整个实例内..可谓霸道无敌...=_=

block外的对象和基本数据同样，也能够做为block的参数。而让人开心的是，block将自动retain传递进来的参数，而不需担忧在 block执行以前局部对象变量已经被释放的问题。这里就不深究这个问题了，只要严格遵循Apple的thread safe来写，block的内存管理并不存在问题。（更新，ARC的引入再次简化了这个问题，彻底不用担忧内存管理的问题了）

因为block的灵活的机制，致使iOS SDK 4.0开始，Apple大力提倡在各类地方应用block机制。最典型的当属UIView的动画了：在4.0前写一个UIView的Animation大概是这样的：

[UIView beginAnimations:@"ToggleSiblings"context:nil]; [UIView setAnimationTransition:UIViewAnimationTransitionCurlUp forView:self.view cache:YES]; [UIViewsetAnimationDuration:1.0f]; // Make your changes [UIView commitAnimations]; 

在一个不知名的小角落里的begin/commit两行代码间写下须要进行的动做，而后静待发生。而4.0后这样的方法直接被discouraged了(虽然还没Deprecated)，取而代之的正是block：

[UIView animateWithDuration:5.0f animations:^{ view.opacity = 0.5f; }]; 

简单明了，一切就这么发生了..

可能有人会以为block的语法很奇怪，不像是OOP的风格，诚然直接使用的block看起来破坏了OOP的结构，也让实例的内存管理出现了某些“看上去奇怪”的现象。可是经过typedef的方法，能够将block进行简单包装，让它的行为更靠近对象一些：

typedef double (^unary_operation_t)(double op); 

定义了一个接受一个double型做为变量，类型为unaryoperationt的block，以后在使用前用相似C的语法声明一个unaryoperationt类型的"实例"，而且定义内容后即可以直接使用这个block了～

unary_operation_t square;  
square = ^(double operand) { return operand * operand; } 

啰嗦一句的仍是内存管理的问题，block始终不是对象，而block的内存管理天然也是和普通对象不同。系统会为block在堆上分 配内存，而当把block当作对象进行处理时（好比将其压入一个NSMutableArray），咱们须要获取它的一份copy（好比[square copy]），而且在Array retain了这个block后将其释放（[square autorelease]是不错的选择）。而对于block自己和调用该block的实例，则能够放心：SDK会将调用block的实例自动 retain，直至block执行完毕后再对实例release，所以不会出现block执行到一半，实例就被dealloc这样的尴尬的局面。 在ARC的时代，这些都是废话了。打开ARC，而后瞎用就能够了。ARC解决了block的最让开发者头疼的最大的也是惟一的问题，内存管理。关于block的内存管理方面，有一个很好玩的小quiz，能够作作玩～传送门

iOS SDK 4.0之后，随着block的加入不少特性也随之添加或者发生了升级。Apple所推荐的block使用范围包括如下几个方面：

• 枚举——经过block获取枚举对象或控制枚举进程
• View动画——简单明了的方式规定动画
• 排序——在block内写排序算法
• 通知——当某事件发生后执行block内的代码
• 错误处理——当错误发生时执行block代码
• 完成处理——当方法执行完毕后执行block代码
• GCD多线程——多线程控制，关于这个之后有机会再写…

 

block使用时应注意的事项：

1.  可访问在同一范围内的全局变量包括静态变量。

2.  能够访问传递给块的参数（如同函数参数）。

3.  同一范围的栈（非static）变量视做const变量。它们的值相似块表达式。嵌套块时，从最近的做用域取值。

4.  在同一范围内声明的变量，若是有__block修饰符修饰，则值是可变的。在该范围内包括同一范围内的其余块对该变量的改变，都将影响该做用域。具体见“__block 存储类型”。

5.  在块的范围内（块体）声明的本地变量，相似于函数中的本地变量。块的每次调用都会致使从新拷贝这些变量。这些变量可做为const或参考（by-reference）变量。

block块回调的例子

Book.h

1 2 3 4 5 6 7 8

#import <Foundation/Foundation.h> typedef  void  (^PublishBlock) (NSString *name); @interface Book : NSObject   @property (nonatomic, strong) PublishBlock block; - ( void ) nslogAll; - ( void ) printAll:(PublishBlock) block; @end

Book.m

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

#import "Book.h"   @implementation Book   -( void )nslogAll{      NSString *name = [NSString stringWithFormat:@ "helloworld!!!" ];      if  (self.block) {          self.block(name);      }      } - ( void )printAll:(PublishBlock)block{      NSString *name = [NSString stringWithFormat:@ "HELLOWORLD!!!" ];      if  (block) {          block(name); // 调用block传值      }   } @end

函数调用时的类名

ViewController.h

1 2 3 4 5 6 7 8 9

#import <UIKit/UIKit.h>       @interface ViewController : UIViewController   - (IBAction)huiDiao_Action:(id)sender;   @end

ViewController.m

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

#import "ViewController.h" #import "Book.h"   @interface ViewController ()   @end   @implementation ViewController   - ( void )viewDidLoad {      [super viewDidLoad];      // Do any additional setup after loading the view, typically from a nib. }   - ( void )didReceiveMemoryWarning {      [super didReceiveMemoryWarning];      // Dispose of any resources that can be recreated. }       - (IBAction)huiDiao_Action:(id)sender {      Book *book = [[Book alloc]init];      book.block = ^(NSString *name){          NSLog(@ "++++xingming:%@" ,name);      };      [book nslogAll];      [book printAll:^(NSString *name) { // block做为参数传递          NSLog(@ "+++++XINGMING:%@" ,name);      }]; }   @end

 

1. 做为属性而存在的Block

testBlock.m文件里

@property (copy, nonatomic) void (^aBlock)();  // MRC下,block属性必须是显式标注copy策略;  ARC下,其实能够不显式标明copy, xcode会自动对block属性采起copy策略

- (void)viewDidLoad {

    [super viewDidLoad];

    self.aBlock = ^{

　　　　NSLog(@"%@",self);

　 };

}

 

　　当block在栈内存时,Block对内部的对象只是弱引用

　　1.1 copy关键字

　　　　block默认是在存储在栈内存, 通过copy,会将block复制到堆内存

 

2. 在方法内部的Block

- (void)viewDidLoad {

    [super viewDidLoad];

    void (^innerFunctionBlock)() = ^{

        NSLog(@"方法内部的block, 有人管这叫内联Block");

    };

    innerFunctionBlock();

}

 

3. 其余

- (void)viewDidLoad { ...2.里的代码块... }

void (^block)() = ^{

　　NSLog(@"相似全局变量的Block, 其实和方法差很少");

};

 

总结: 1. 若是没有对block作copy操做, block就存储于栈内存

        2. 若是对block作copy操做, block就存储于堆内存

        3. 若是block存储于栈空间, 对block内部的所用到的外部对象,是弱引用

        4. 若是block存储于堆空间, 对block内部的所用到的外部对象,是强引用

        5. 解除循环引用的方法: 5.1 ARC:使用 __weak, 有时不能用__weak,那就用 __unsafe_unretained , 这种状况极少发生

　　　　　　　　　　　　　　5.2 MRC:使用__block

                                        5.3 在调用完block以后,将block = nil

        6.  NSInteger a = 1;  

　　　　 void (^testBlock)(void) =  ^{

　　　　　   NSLog(@"a=%d",a);

　　　　 };

　　　　 ++a;

　　　　 testBlock();

            打印出来确定仍是1, 由于block在编译阶段就肯定了, 编译的时候block内部的 NSLog(@"a=%d",a)  等价于  NSLog(@"a=%d",1) ，此时a在代码块中是value type，此时是不能改变值的；

　　　　 想要block内部的a是引用,须要用到__block声明变量a: __block NSInteger a = 1;  这样编译编辑阶段,block内部的 NSLog(@"a=%d",a)  等价于  NSLog(@"a=%d",*(&a))

 　　 7.  不要迷信xcode能帮你检查出全部block的循环引用问题,xcode只能检查出比较浅显的,这个尤为须要注意

 

 

仔细研读4.0的SDK的话，会发现不少经常使用类中都加入了很多带block做为参数的方法，改变固有思惟习惯，适应并尽量利用block给程序上带来的便捷，无疑是提升效率和使代码优雅的很好的途径～