简介

Blocks是C语言层级语法和运行时特性。 它们类似于标准C函数，但是除了可执行代码之外，它们还可以保存堆栈变量。 因此，块可以保存数据，在代码执行时使用。
1、Block可以作为函数数调用、作为函数参数、作为方法参数。
2、因为独立完整可以在多线程中使用；
3、因为拥有回调时需要执行的代码和执行代码时需要的数据，常常被用来实现回调Callback。
由于Objective-C和C++都是从C派生，因此三种语言均可以使用（Objective-C使用更多）。iOS从4.0版本开始支持。在其他语言环境中有时被称为“闭包”。

特点

Block是一个匿名的内联代码集合，有以下特点：
1、像函数一样用参数列表
2、有可推断或者声明的返回值类型
3、可以从定义它作用域捕获数据
4、可选的可以修改捕获到的数据
5、同一作用域中的其它block共享捕获的数据
6、作用域的堆栈被销毁后，仍然可以继续共享定义其范围定义的数据
由于compiler 和 runtime 保证block和其相关的数据的生命周期，因此可以copy一份传递到其他地方使用。

声明和创建

声明

首先说明下函数指针的声明格式

返回值类型 ( * 指针变量名) ([形参列表]);

Block variables保存着block的引用。可以像声明函数指针一样声明block变量，但是要把*换成^,例如以下均为有效的声明

void (^blockReturningVoidWithVoidArgument)(void);
int (^blockReturningIntWithIntAndCharArguments)(int, char);
void (^arrayOfTenBlocksReturningVoidWithIntArgument[10])(int);

Blocks支持可变的参数列表，当没有参数时必须写void。
通过为编译器提供block使用的数据，传递参数，返回值，block设计完全类型安全。可以把block引用强制转换成任意类型的指针，反之亦然。但是不能使用操作符*来访问值，因为block的值在编译期无法计算。
理解：假如每次方法调用当做一次消息发送（一般底层会有很多次），把block中的所以消息发送按照顺序放到一种能够先进先出的数据结构–比方说实现栈特性的结构体；那么block变量和^{ ... }作用一样都是指向结构体的首地址；传递首地址跟其他对象指针、函数指针用法很像。

类型定义简化用法

如果经常重复使用同一个类型的block，你可以定义自己的block类型，例如

//返回值类型：float 两个参数类型：float 变量名称：MyBlockType
typedef float (^MyBlockType)(float, float);

MyBlockType myFirstBlock = // ... ;
MyBlockType mySecondBlock = // ... ;

创建

^表示block的开始，接一个返回值类型（可选，默认不写）再接一个(参数列表)，后边接一个{代码块};例如

int multiplier = 7;
int (^myBlock)(int) = ^(int num) {
    return num * multiplier;
};

解读如下图所示
如果没有明确声明返回值类型，则根据block代码内容推断具体类型，例如

int multiplier = 7;

//未指明返回值类型
int (^myBlock)(int) = ^(int num) {
    return num * multiplier;
};

//指明返回值类型
int (^myBlock)(int) =  ^ int (int num) {
   return multiplier;
};

Blocks和变量

首先可以像函数一样引用三种标准类型的变量：
1、全局变量，包括静态局部变量
2、全局函数
3、作用域内的局部变量和参数
其次Blocks还支持另外两种类型：
4、__block修饰的变量
5、const导入的
所以Blocks内部处理变量的五种情况：
1、全局变量（包括作用域内的静态局部变量）可以直接访问
2、Blocks的参数可以直接访问
3、作用域内非静态局部变量，作为const变量引用（只读）,强行修改编译器报错
4、被__block修饰的作用域内非静态局部变量，可以直接访问
5、Blocks内部声明的局部变量，可以直接访问
示例代码如下

int global_var = 1;

- (void)viewDidLoad {
[super viewDidLoad];


static int static_var = 2;

__block int loacal_var = 3;

__block int const_var = 3;

void (^myBlock)(int) = ^(int number) {

   global_var = global_var * 10;
   static_var = static_var * 10;
   loacal_var = loacal_var * 10;
   number     = number * 10;
   NSLog(@"局部变量：%d ，说明局部变量可以读取",const_var);
   NSLog(@"参数变量原：4 修改后%d，说明可以正常访问",number);

};
myBlock(4);

NSLog(@"全局变量原：1 修改后：%d，说明可以正常访问 ",global_var);
NSLog(@"静态变量原：2 修改后：%d，说明可以正常访问 ",static_var);
NSLog(@"__block修饰的局部变量原：3 修改后：%d，说明可以正常访问 ",loacal_var);
}

//输出结果
局部变量：3 ，说明局部变量可以读取
参数变量原：4 修改后40，说明可以正常访问
全局变量原：1 修改后：10，说明可以正常访问 
静态变量原：2 修改后：20，说明可以正常访问 
__block修饰的局部变量原：3 修改后：30，说明可以正常访问 

Blocks和对象

对象通过Properties来引用Blocks。语法和定义Blocks语法类似；例如

@interface XYZObject : NSObject
@property (copy) void (^blockProperty)(void);
@end

self.blockProperty = ^{
   ...
};
self.blockProperty();

注意：此处应该用copy，因为block需要被copy来保存引用的外界的变量，无需关心引用计数问题，编译器自动进行管理。

还可以通过自定义类型简化

typedef void (^XYZSimpleBlock)(void);

@interface XYZObject : NSObject
@property (copy) XYZSimpleBlock blockProperty;
@end

避免循环引用

当变量变成实例变量的时候，需要避免循环引用的问题。由于Blocks会持有使用的变量，比如在Viewcontroller中，block作为一个property被self持有，block中使用self调用方法，这样便造成循环引用的问题使得二者在不使用时均得不到释放。解决方法是在block中使用self的弱引用，用__weak修饰。

@interface XYZBlockKeeper : NSObject
@property (copy) void (^block)(void);
@end

- (void)configureBlock {
    XYZBlockKeeper * __weak weakSelf = self;
    self.block = ^{
        [weakSelf doSomething];   // capture the weak reference
                                  // to avoid the reference cycle
    }
}

用法

作为变量

如果声明Block作为一个变量，可以像函数一样调用。例如

int (^oneFrom)(int) = ^(int anInt) {
    return anInt - 1;
};

printf("1 from 10 is %d", oneFrom(10));
// Prints "1 from 10 is 9"

float (^distanceTraveled)(float, float, float) =
                         ^(float startingSpeed, float acceleration, float time) {

    float distance = (startingSpeed * time) + (0.5 * acceleration * time * time);
    return distance;
};

float howFar = distanceTraveled(0.0, 9.8, 1.0);
// howFar = 4.9

作为函数参数

可以像传递其它参数一样传递block。大多数的情况不需要声明，只需要作为参数以内联的方式实现。例如

char *myCharacters[3] = { "TomJohn", "George", "Charles Condomine" };

//根据首字符进行一次排序 
qsort_b(myCharacters, 3, sizeof(char *), ^(const void *l, const void *r) {
    char *left = *(char **)l;
    char *right = *(char **)r;
    //此函数表示：以参数3的长度计算前2个参数的差值
    return strncmp(left, right, 1);
});

// Block implementation ends at "}"

// myCharacters is now { "Charles Condomine", "George", "TomJohn" }

作为方法参数

Cocoa Touch 提供了很多方法使用Blocks。可以传递block作为参数使用。例如

//是否包含指定字符串
__block BOOL found = NO;
NSSet *aSet = [NSSet setWithObjects: @"Alpha", @"Beta", @"Gamma", @"X", nil];
NSString *string = @"gamma";

[aSet enumerateObjectsUsingBlock:^(id obj, BOOL *stop) {
    if ([obj localizedCaseInsensitiveCompare:string] == NSOrderedSame) {
        *stop = YES;
        found = YES;
    }
}];

// At this point, found == YES

作用

很大程度上起到了简化的作用。

简化回调

Blocks可以用处替换传统回调的原因如下：
1、方法调用和回调代码集中在一起；还常作为framework methods的参数。
2、可以直接访问局部变量。

简化枚举

对一个数组进行枚举，常用的方法有3种
1、for循环
2、for的泛型遍历for (type *object in collection)
3、使用带有block的简化方法。例如- (void)enumerateObjectsUsingBlock:(void (^)(id obj, NSUInteger idx, BOOL *stop))block;

NSArray *array = @[@"A", @"B", @"C", @"A", @"B", @"Z", @"G", @"are", @"Q"];

//for循环
for (int i = 0; i < array.count; i ++)
{

   NSString *item = array[i];
   NSLog(@"index:%d value:%@",i,item);
}

 //泛型遍历   
for (NSString *item in array)
{
   NSLog(@"value:%@",item);
}

 //枚举方法   
[array enumerateObjectsUsingBlock:^(id  _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
   NSLog(@"index:%ld value:%@",idx,obj);

}];

简化并发任务

每个block都是独立的工作单元，包含可执行代码和保存使用的数据，这使得它能够在多线程开发中被异步调用。
系统提供了一系列的多线程编程技术，其中包括两种任务调度机制：Operation queues 和 Grand Central Dispatch（GCD）。不像Thread关注怎么样管理运行，把需要执行的任务打包到blocks中，然添加到队列中，然后交给系统根据当时的资源自动执行。

简化Operation Queues

//定义任务
NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
    ...
}];

// 主线程执行
NSOperationQueue *mainQueue = [NSOperationQueue mainQueue];
[mainQueue addOperation:operation];

// 后台执行
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
[queue addOperation:operation];

简化Grand Central Dispatch

//获取并发队列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

//定义任务添加到队列并执行
dispatch_async(queue, ^{
    NSLog(@"Block for asynchronous execution");
});