一，概念

Block是将函数及其执行上下文封装起来的匿名函数和代码块。它是C语言的扩充功能。之所以是拓展，是因为C语言不允许存在这样匿名函数。
block的标准定义如下

return_type (^blockName)(var_type) = ^return_type (var_type varName) {
    // ...
};
blockName(var);

• return_type:block 的返回值类型，
• blockNameblock 的名字
• var_type block 的参数类型
• varName 参数名字
  例如如下定义

    NSInteger num = 3;
    NSInteger(^IntBlock)(NSInteger) = ^NSInteger(NSInteger n){
        //返回值是NSInteger 类型，参数也是NSInteger类型，这就是一个典型的带返回值的block
        return num * n;
    };
    
    //最后条用相应定义的block
    
    NSInteger muplyValue =  IntBlock(5);
    NSLog(@"最后的block乘积是 %ld",muplyValue);

我们通过clang -rewrite-objc Myobject.m命令查看相应的.cpp文件，可以发现MyObject中block的实现变成了相应的底层代码如下

 NSInteger num = 3;
 NSInteger(*IntBlock)(NSInteger) = ((NSInteger (*)(NSInteger))&__Myobject__init_block_impl_0((void *)__Myobject__init_block_func_0, &__Myobject__init_block_desc_0_DATA, num));
((NSInteger (*)(__block_impl *, NSInteger))((__block_impl *)IntBlock)->FuncPtr)((__block_impl *)block, 4);

其中相应的block的结构是

struct __Myobject__init_block_impl_0 {
  struct __block_impl impl;
  struct __Myobject__init_block_desc_0* Desc;
  NSInteger num;
  __Myobject__init_block_impl_0(void *fp, struct __Myobject__init_block_desc_0 *desc, NSInteger _num, int flags=0) : num(_num) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

__block_impl结构体为

struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};

block内部有isa指针，所以说其本质也是OC对象
block的内部实现为

static NSInteger __Myobject__init_block_func_0(struct __Myobject__init_block_impl_0 *__cself, NSInteger n) {
  NSInteger num = __cself->num; // bound by copy

            return num * n;
        }

所以说 Block是将函数及其执行上下文封装起来的对象
既然block内部封装了函数，那么它同样也有参数和返回值。

匿名函数定义以及调用

匿名函数是指不带函数名称函数。C语言中，函数是怎样的呢？类似这样：

    1、//直接调用匿名函数
    int pingFang = func(4); //匿名函数调用
    NSLog(@"数据的平方是 %ld",pingFang);
    //此处用的是OC的打印函数

//通过指针函数调用匿名函数
    int (*funcptr)(int) = &func;
    int another = (*funcptr)(10);
    NSLog(@"数据的平方是 %ld",pingFang);
    
}

int func(int para){ //匿名函数的声明
    
    return para * para;
}

func就是它的函数名。也可以通过指针调用函数，看起来没用到函数名，
而通过Block，就能够使用匿名函数，即不带函数名称的函数

二,Block 的捕获

2.1block的变量捕获

关于“带有自动变量（局部变量）”的含义，这是因为Block拥有捕获外部变量的功能。在Block中访问一个外部的局部变量，Block会持用它的临时状态，自动捕获变量值，外部局部变量的变化不会影响它的的状态。
例如如下一道经典面试题

   int val = 10;
    void(^vBlock)(void) = ^{
        NSLog(@"val's value is %d",val);
    };
    val = 2;
    vBlock();

上面这段代码，输出值是：val = 10，而不是2。
因为block 在实现时就会对它引用到的它所在方法中定义的栈变量进行一次只读拷贝，然后在 block 块内使用该只读拷贝；换句话说block截获自动变量的瞬时值；或者block捕获的是自动变量的副本。

由于block捕获了自动变量的瞬时值，所以在执行block语法后，即使改写block中使用的自动变量的值也不会影响block执行时自动变量的值。

所以，上面的面试题的结果是10，不是2。

同理也是

    NSInteger num = 3;
    NSInteger(^IntBlock)(NSInteger) = ^NSInteger(NSInteger n){
        //返回值是NSInteger 类型，参数也是NSInteger类型，这就是一个典型的带返回值的block
        return num * n;
    };
    
    num = 1;
    
    //最后条用相应定义的block
    NSInteger muplyValue =  IntBlock(5);
    NSLog(@"最后的block乘积是 %ld",muplyValue);

输出结果是

2020-08-18 10:58:32.352451+0800 Block 的实现过程[8583:115207] 最后的block乘积是 15

同样，在block里如果修改变量num，也是无效的，甚至编译器会报错。

   NSMutableArray *array = [[NSMutableArray alloc]initWithObjects:@"1",@"2", nil];
    
    void(^Blck)(void) = ^{
        
        NSLog(@"array = %@",array);
        [array addObject:@"4"];
        
    };
    
    [array addObject:@"3"];
  
    array = nil;
  
    Blck();

2020-08-18 11:08:28.371636+0800 Block 的实现过程[8650:122882] array = (
1,
2,
3
)
打印为1，2，3
局部对象变量也是一样，截获的是值，而不是指针，在外部将其置为nil，对block没有影响，而该对象调用方法会影响

2.2,block的局部静态变量截获 是指针截获。

例如如下代码

    static NSInteger sum = 10;
    NSInteger(^SBlock)(NSInteger) = ^NSInteger(NSInteger n){
        
        return sum * n;
        
    };
    
    sum = 1;
    
    NSInteger secondValue = SBlock(2);
    
    NSLog(@"静态的值是  %ld",secondValue);

输出为2，意味着sum = 1这里的修改sum值是有效的，即是指针截获。
同样，在block里去修改变量m，也是有效的。

2.3，全局变量，静态全局变量截获：不截获,直接取值。

static NSInteger num3 = 300;

NSInteger num4 = 3000;

- (void)blockTest
{
    NSInteger num = 30;
    
    static NSInteger num2 = 3;
    
    __block NSInteger num5 = 30000;
    
    void(^block)(void) = ^{
        
        NSLog(@"%zd",num);//局部变量
        
        NSLog(@"%zd",num2);//静态变量
        
        NSLog(@"%zd",num3);//全局变量
        
        NSLog(@"%zd",num4);//全局静态变量
        
        NSLog(@"%zd",num5);//__block修饰变量
    };
    
    block();
}

编译后

struct __WYTest__blockTest_block_impl_0 {
  struct __block_impl impl;
  struct __WYTest__blockTest_block_desc_0* Desc;
  NSInteger num;//局部变量
  NSInteger *num2;//静态变量
  __Block_byref_num5_0 *num5; // by ref//__block修饰变量
  __WYTest__blockTest_block_impl_0(void *fp, struct __WYTest__blockTest_block_desc_0 *desc, NSInteger _num, NSInteger *_num2, __Block_byref_num5_0 *_num5, int flags=0) : num(_num), num2(_num2), num5(_num5->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

（ impl.isa = &_NSConcreteStackBlock;这里注意到这一句，即说明该block是栈block）
可以看到局部变量被编译成值形式，而静态变量被编成指针形式，全局变量并未截获。而__block修饰的变量也是以指针形式截获的，并且生成了一个新的结构体对象：

struct __Block_byref_num5_0 {
  void *__isa;
__Block_byref_num5_0 *__forwarding;
 int __flags;
 int __size;
 NSInteger num5;
};

该对象有个属性：num5，即我们用__block修饰的变量。
这里__forwarding是指向自身的(栈block)。
一般情况下，如果我们要对block截获的局部变量进行赋值操作需添加__block
修饰符，而对全局变量，静态变量是不需要添加__block修饰符的。
另外，block里访问self或成员变量都会去截获self。

三，Block的几种形式

Block分为

• 全局Block(_NSConcreteGlobalBlock)、
• 栈Block(_NSConcreteStackBlock)、
• 堆Block(_NSConcreteMallocBlock)三种形式

其中栈Block存储在栈(stack)区，堆Block存储在堆(heap)区，全局Block存储在已初始化数据(.data)区

3.1 不使用外部变量的block是全局block

   NSLog(@"block 类型   %@",[^{
        
        NSLog(@"相应的globalBlock");
        
    } class]);

输出:

2020-08-18 15:15:40.281201+0800 Block 的实现过程[9451:241770] block 类型   __NSGlobalBlock__ 

3.2 使用外部变量并且未进行copy操作的block是栈block

   NSInteger num = 10;
    NSLog(@"block 类型   %@",[^{
        
        NSLog(@"相应的stackBlock   %ld",num);
        
    } class]);
    

输出

2020-08-18 15:21:54.512095+0800 Block 的实现过程[9473:246942] block 类型   __NSStackBlock__

3.3,对栈block进行copy操作，就是堆block，而对全局block进行copy，仍是全局block

• 比如堆1中的全局进行copy操作，即赋值

  void(^globalBlock)(void) = ^{
        
        NSLog(@"globalBlock");
    };
    
    NSLog(@" %@",[globalBlock class]);

输出

2020-08-18 15:27:17.756952+0800 Block 的实现过程[9501:252286]  __NSGlobalBlock__

仍是全局block

• 而堆2中的栈block进行赋值操作：

 NSInteger num = 4;
    void (^mallocBlock)(void) = ^{

            NSLog(@"stackBlock:%zd",num);
        };

  NSLog(@"%@",[mallocBlock class]);

输出：

2020-08-18 15:40:41.191736+0800 Block 的实现过程[9563:261995] __NSMallocBlock__

对栈blockcopy之后，并不代表着栈block就消失了，左边的mallock是堆block，右边被copy的仍是栈block

3.4，即如果对栈Block进行copy，将会copy到堆区，对堆Block进行copy，将会增加引用计数，对全局Block进行copy，因为是已经初始化的，所以什么也不做。

另外，__block变量在copy时，由于__forwarding的存在，栈上的__forwarding指针会指向堆上的__forwarding变量，而堆上的__forwarding指针指向其自身，所以，如果对__block的修改，实际上是在修改堆上的__block变量。

四，Block的使用注意事项

4.1截获自动变量与__block说明符

前面讲过block所在函数中的，捕获自动变量。但是不能修改它，不然就是“编译错误”。但是可以改变全局变量、静态变量、全局静态变量。其实这两个特点不难理解：

• 不能修改自动变量的值是因为：block捕获的是自动变量的const值，名字一样，不能修改
• 可以修改静态变量的值：静态变量属于类的，不是某一个变量。由于block内部不用调用self指针。所以block可以调用。

解决block不能修改自动变量的值，这一问题的另外一个办法是使用__block修饰符。

4.2 Block引起的循环引用

一般来说我们总会在设置Block之后，在合适的时间回调Block，而不希望回调Block的时候Block已经被释放了，所以我们需要对Block进行copy，copy到堆中，以便后用。

Block可能会导致循环引用问题，因为block在拷贝到堆上的时候，会retain其引用的外部变量，那么如果block中如果引用了他的宿主对象，那很有可能引起循环引用，

• MRC情况下，用__block可以消除循环引用。
• ARC情况下，必须用弱引用才可以解决循环引用问题，iOS 5之后可以直接使用__weak，之前则只能使用__unsafe_unretained了，__unsafe_unretained缺点是指针释放后自己不会置空

4.3 所有的Block里面的self必须要weak一下？

很显然答案不都是，有些情况下是可以直接使用self的，比如调用系统的方法：

[UIView animateWithDuration:0.5 animations:^{
        NSLog(@"%@", self);
    }];

因为这个block存在于静态方法中，虽然block对self强引用着，但是self却不持有这个静态方法，所以完全可以在block内部使用self。

另外，来看一个Masonry代码布局的例子，这里面的self会不会造成循环引用呢？

[self.headView mas_makeConstraints:^(MASConstraintMaker *make) {
    make.centerY.equalTo(self.otherView.mas_centerY);
}];

并不是 block 就一定会造成循环引用，是不是循环引用要看是不是相互持有强引用。block 里用到了 self，那 block 会保持一个 self 的引用，但是 self 并没有直接或者间接持有 block，所以不会造成循环引用。可以看一下Masonry的源代码：