Block 代码块

闭包 = 一个函数「或指向函数的指针」+ 该函数执行的外部的 上下文变量「也就是自由变量」
Block 是 Objective-C 对于闭包的实现

简介

• 可以嵌套定义，定义 Block 方法和定义函数方法相似
• Block 可以定义在方法内部或外部
• 只有调用 Block 时候，才会执行其{}体内的代码
• 本质是对象，使代码高聚合

使用 clang 将 OC 代码转换为 C++ 文件查看 block 的方法

• 在命令行输入以下代码 clang -rewrite-objc 需要编译的OC文件.m
• 这时查看当前的文件夹里 多了一个相同的名称的 .cpp 文件，在命令行输入 open main.cpp 查看文件

I. 定义格式

• 立刻执行的 block
  ^{ /*执行的代码*/ }();

• 默认格式
  返回值类型 (^Block变量名)(形参列表) = ^返回值类型 (形参列表){ 内容 }
  返回值类型通常省略，根据 内容中的 return 返回值的类型来决定最终类型，如果没有 return 语句，则返回值类型默认为 void

• 有参
  返回值类型 (^Block变量名)(形参列表) = ^(形参列表){ 内容 };

• 无参
  返回值类型 (^Block变量名)(形参列表) = ^(){ 内容 };
返回值类型 (^Block变量名)(形参列表) = ^{ 内容 };

II. 使用方法

• 作为变量的方法「Xcode快捷键：inlineBlock」

int (^sum) (int, int); // 定义一个 Block 变量 sum
// 给 Block 变量赋值
// 一般 返回值省略：sum = ^(int a,int b)…
sum = ^int (int a,int b){  
    return a+b;
}; // 赋值语句最后有 分号
int a = sum(10,20); // 调用 Block 变量

• 作为属性的方法「Xcode 快捷键：typedefBlock」

// 1. 给  Calculate 类型 sum变量 赋值「下定义」
typedef int (^Calculate)(int, int); // calculate就是类型名
Calculate sum = ^(int a,int b){ 
    return a+b;
};
int a = sum(10,20); // 调用 sum变量

// 2. 作为对象的属性声明，copy 后 block 会转移到堆中和对象一起
@property (nonatomic, copy) Calculate sum;    // 使用   typedef
@property (nonatomic, copy) int (^sum)(int, int); // 不使用 typedef

// 声明，类外
self.sum = ^(int a,int b){
    return a+b;
};
// 调用，类内
int a = self.sum(10,20);

• 作为函数参数
  例：请求网络数据（延迟）先把展示到控件的代码保存到block中，等请求到数据的时候直接调用block

// 实现，不使用 typedef
// void (^iblock)()作为函数参数类型，iblock函数形参名
void iprint( void (^iblock)() ){ 
    iblock(); // 调用 block参数}

// 实现，使用 typedef
typedef void (^IBlock)();
void iprint(IBlock iblock){
    iblock(); // 调用 block参数

}

// 调用「不管使用不使用 typedef 调用方式一致」
iprint(^{
    NSLog(@"传入的实参代码块区域");
});

• 作为 OC 中的方法参数

// ---- 无参数传递的 Block ---------------------------
// 实现
- (CGFloat)testTimeConsume:(void(^)())middleBlock {
    // 执行前记录下当前的时间
    CFTimeInterval startTime = CACurrentMediaTime();
    middleBlock();
    // 执行后记录下当前的时间
    CFTimeInterval endTime = CACurrentMediaTime();
    return endTime - startTime;

}

// 调用
[self testTimeConsume:^{
       // 放入 block 中的代码 

}];

// ---- 有参数传递的 Block ---------------------------
// 实现
- (CGFloat)testTimeConsume:(void(^)(NSString * name))middleBlock {
    // 执行前记录下当前的时间
    CFTimeInterval startTime = CACurrentMediaTime();
    NSString *name = @"有参数";
    middleBlock(name);
    // 执行后记录下当前的时间
    CFTimeInterval endTime = CACurrentMediaTime();
    return endTime - startTime;
}

// 调用
[self testTimeConsume:^(NSString *name) {
   // 放入 block 中的代码，可以使用参数 name
   // 参数 name 是实现代码中传入的，在调用时只能使用，不能传值    

}];

III. 访问外界变量

• 不访问外界变量，block 既不在 栈 又不在 堆 中，在代码段中「ARC 和 MRC 下都是如此」

void (^myblock)(void) = ^(){
    printf("不访问 block 作用域范围外的外界变量\n");
};
myblock();  // 在代码段中和 C 函数一样

• 默认情况下，可以访问，不能修改 外界变量的值
  MRC 环境下访问外界变量的 block 默认存储在 栈 中
  ARC 环境下访问外界变量的 block 默认存储在 堆 中，自动释放

int a = 4;
char text[] = "fuckBlock";

char *p = text;
NSMutableArray *arr = [NSMutableArray array];

void (^myblock)(void) = ^(){
    [arr addObject:@(a)];    // 能修改对象 arr 内部的值
    NSLog(@"a = %d",a);      // 能访问变量 a   的值
    NSLog(@"arr = %@",arr);  // 能访问对象 arr 的值
    NSLog(@"%c",p[2] = 'F'); // 能访问指着 指向的值，并修改内容
    NSLog(@"%c",text[2]);    // 不能访问 C 语言数组及其内容，这里编译器会报错
    a = 5;                   // 不能修改变量 a   的值，这里编译器会报错
    arr = [NSMutable array]; // 不能修改对象 arr 的值，这里编译器会报错
};

myblock();    // 在调用 block 时，深复制变量 a 和对象 arr 的值到 block 数据结构中
printf("after block a = %d\n",a); // 两次 a 输出都是 4

• 使用 __block 修改外界变量
  ARC 下：访问外部对象用 __block 修饰：访问对象会进行 1 次 retain 操作
  MRC 下：访问外部对象用 __block 修饰：访问对象不会进行 retain 操作

__block int a = 4;
void (^myblock)(void) = ^(){
    // 此时，该 block 对象会持有 __block 的值 a
    // 多个 block 对象会持有 同一个 __block 的值 a
    a = 5;    // 能修改
    printf("%d\n",a); // 复制 a 的引用地址，能访问
};
myblock();    // block 在栈中
printf("%d\n",a); // 两次输出都是 5

• block 从栈 复制到 堆 编译器自动复制的情况
  block 调用 copy 方法
  block 作为函数返回值返回
  block 赋值给 __strong 修饰的 id 类型 或 block 类型的成员变量 时
  方法名含有 usingBlock 的 Cocoa 框架方法 或 GCD 的 API 接口传入的 block 时

• block 被 copy 时，block 被复制到 堆
  block 在 栈 中，copy，从栈复制到 堆
  block 在 代码段 中，copy，什么也不做
  block 在 堆 中，copy，引用计数+1

// 1. 简单示例

[blockName copy];      // block 的 copy 操作
Block_copy(blockName); // block 的 copy 操作「宏定义方法，在 ARC 模式下会出错」

// 2. 编译器在部分情况下会自动将 block 从 栈复制到堆中，但有些情况需要手动复制
- (NSArray *)getBlockArray {
    int val = 10;
    // block 就是对象，所以可以直接加入到数组中，并且有 copy 方法
    return [[NSArray alloc] initWithObjects:
            [^{ NSLog(@"block_0:%d",val); } copy],
            [^{ NSLog(@"block_1:%d",val); } copy], nil];

}

IV. 防止 Block 循环引用的方法

• Block 循环引用的情况
  某个类将 block 作为自己的属性变量，然后该类在 block 的方法体里面又使用了该类本身
  self.someBlock = ^(Type var){[self dosomething];};
• 解决方法「ARC 下：使用 __weak」

__weak typeof(self) weakSelf = self;
self.someBlock = ^(Type var){
   [weakSelf dosomething];
};

• 解决方法「MRC 下：使用 __block」
  优点：可控制对象的持有期间
  缺点：为了避免循环引用，必须执行 block

__block typeof(self) blockSelf = self;
self.someBlock = ^(Type var){
   [blockSelf dosomething];
};

• 使用 __block 带来的循环引用「ARC」

// 循环引用 self -> _attributBlock -> tmp -> self
typedef void (^Block)();
@interface TestObj : NSObject
{
    Block _attributBlock;
}
@end

@implementation TestObj
- (id)init {
    self = [super init];
    __block id tmp = self;
    self.attributBlock = ^{
        NSLog(@"Self = %@",tmp);
        tmp = nil;
   };
}

- (void)execBlock {
    self.attributBlock();
}
@end

// 使用类
id obj = [[TestObj alloc] init];
[obj execBlock]; // 如果不调用此方法，tmp 永远不会置 nil，内存泄露会一直在