iOS底层原理探索Block基本使用

block是什么？

block其实是一段代码块，其作用是保存一段代码块，在真正调用block的时候，才执行block里面的代码。

在程序里面输入inlineBlock，就可以得到block的声明与定义形式：

/**
 等号前面是block的声明；
 等号后面是block的定义；
 returnType:block声明的返回类型
 blockName:block的名字
 parameterTypes:block声明的参数类型
 parameters:block定义的参数类型及参数值
 statements:block代码块
 */
returnType(^blockName)(parameterTypes) = ^(parameters) {
    statements
};//末尾的；不能省略

block的定义常见的有四种形式：

1. 无参数，无返回值
2. 无参数，有返回值
3. 有参数，无返回值
4. 有参数，有返回值

我们具体看一下四种常见的形式以及各个形式的类型都长什么样：

- (void)viewDidLoad {
    [super viewDidLoad];
    /**
     1.无参数，无返回值
     定义的时候，没有返回值可以不写()及里面的内容
     其block类型是：void(^)(void)
     */
    void(^block1)(void) = ^{
        NSLog(@"block1");
    };
    
    /**
     2.1无参数，有返回值
     其block类型是：int(^)(void)
     */
    int(^block21)(void) = ^int{
        NSLog(@"block21");
        return 21;
    };
    
    /**
     2.2无参数，有返回值
     定义的时候，返回值可以省略
     其block类型是：int(^)(void)
     */
    int(^block22)(void) = ^{
        NSLog(@"block22");
        return 22;
    };
    
    /**
     3.有参数，无返回值
     有参数的情况下，声明的参数类型必须写
     有参数的情况下，定义的参数类型和参数名必须写
     其block类型是：void(^)(int)
     */
    void(^block3)(int) = ^(int a){
        NSLog(@"block3---%d", a);
    };
    
    /**
     4.有参数，有返回值
     定义的时候，返回值int可以省略
     其block类型是：int(^)(int)
     */
    int(^block4)(int) = ^int(int a){
        NSLog(@"block4---%d", a);
        return 4;
    };
    
    /**block的调用*/
    block1();
    int a = block21();
    NSLog(@"%d", a);
    int b = block22();
    NSLog(@"%d", b);
    block3(3);
    NSLog(@"%d", block4(4));
}

运行结果：

2020-03-06 15:23:18.860990+0800 test001[3456:921319] block1
2020-03-06 15:23:18.861075+0800 test001[3456:921319] block21
2020-03-06 15:23:18.861100+0800 test001[3456:921319] 21
2020-03-06 15:23:18.861122+0800 test001[3456:921319] block22
2020-03-06 15:23:18.861141+0800 test001[3456:921319] 22
2020-03-06 15:23:18.861161+0800 test001[3456:921319] block3---3
2020-03-06 15:23:18.861190+0800 test001[3456:921319] block4---4
2020-03-06 15:23:18.861211+0800 test001[3456:921319] 4

通过以上代码，我们可以得出一下结论：

block在定义的时候，参数为空的时候，可以将定义里面的()以及内容都省略
block在定义的时候，参数不为空的时候，参数值和参数名都不可以省略
block在定义的时候，返回值不管有或者没有都可以省略

block的声明

在interface里面声明block的时候，有两种方法：

typedef void(^BLOCK2)(void);

@interface ViewController ()
/**在ARC下，strong和copy修饰block都可以*/

/**直接声明，按照block的声明样式写就可以*/
@property (strong, nonatomic) void(^block1)(void);

/**将BLOCK2进行定义类型，然后在定义变量block2*/
@property (strong, nonatomic) BLOCK2 block2;
@end

block使用场景-反向传值

我们知道，两个对象的传值有两种：正向传值和反向传值。
其中，正向传值可以直接将值赋值过去完成传值动作。
而反向传值，一般有三种方法：代理、block和通知，然后，我们介绍一下block的反向传值。

/**
ViewController
*/
#import "ViewController.h"
#import "TestViewController.h"
@interface ViewController ()
@end
@implementation ViewController
- (void)viewDidLoad {
    [super viewDidLoad];
}

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
    TestViewController *testVc = [[TestViewController alloc] init];
    testVc.myBlock = ^(int value) {
        NSLog(@"value = %d", value);
    };
    
    [self presentViewController:testVc animated:YES completion:nil];
}

/**TestViewController*/
@interface TestViewController : UIViewController
@property (strong, nonatomic) void(^myBlock)(int value);
@end

#import "TestViewController.h"
@interface TestViewController ()
@end

@implementation TestViewController
- (void)viewDidLoad {
    [super viewDidLoad];
    self.view.backgroundColor = [UIColor redColor];
}

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
    if (self.myBlock) {
        self.myBlock(100);
    }
}
@end

两次点击后，打印如下：
2020-03-06 17:49:31.981064+0800 test001[3497:936661] value = 100

第一次点击屏幕，会呼出TestViewController，
第二次点击屏幕，会调用myBlock(100)，其实它是做了如下操作：

在TestViewController中myBlock(100);的调用等价于：
if (self.myBlock) {
        value = 100;
        ^(int value) {
            NSLog(@"value = %d", value);
        }();
    }

block在MRC下的内存存储地址

首先我们要明确一点的是，block其实是一个对象，那么，block这个对象，存储在什么区呢？
我们知道，内存分为五大区：
栈stack(系统) | 堆malloc、heap(手动) | 静态区(全局区) | 常量区 | 方法区(程序代码区)

block存储在哪个区呢？

这个，需要根据项目是MRC或者ARC做具体的判断。

在讲MRC或者ARC前，我们先了解一些基本知识点：

ARC管理原则：
只要一个对象没有被强指针引用，该对象就会被销毁。
默认局部变量对象都是使用强指针引用，并存放在堆里面。
MRC管理原则：
MRC没有strong、weak修饰指针，局部变量对象做基本数据类型处理，基本数据类型统一放在栈区。
MRC常用知识点:
MRC给属性赋值的时候，一定要用set方法，不能直接访问下划线成员属性。因为，在MRC下的set方法会做一些其他事情，而直接用_成员属性就不会做这些事情。

在MRC下，@property (retain, nonatomic) NSString *name;该句代码的set方法的实现转换为下面代码：
- (void)setName:(NSString *)name
{
    if (_name != name) {
        [_name release];
        _name = [name retain];
    }
}

首先，我们看下在MRC环境下block的存储位置
将Build Setting下的Objective-C Automatic Reference Counting设置为NO即是在MRC环境下

void(^block)(void) = ^{
    NSLog(@"调用了block");
};
NSLog(@"%@", block);
结果：<__NSGlobalBlock__: 0x1006a0080>

int a = 3;//局部变量
void(^block)(void) = ^{
    NSLog(@"调用了block, a = %d", a);
};
NSLog(@"%@", block);
结果:<__NSStackBlock__: 0x16f971328>

__block int a = 3;
void(^block)(void) = ^{
    NSLog(@"调用了block, a = %d", a);
};
NSLog(@"%@", block);
结果:<__NSStackBlock__: 0x16f935310>

static int a = 3;//static修饰局部变量
void(^block)(void) = ^{
    NSLog(@"调用了block, a = %d", a);
};
NSLog(@"%@", block);
结果:<__NSGlobalBlock__: 0x1008ec080>

int global = 5;
- (void)viewDidLoad {
    [super viewDidLoad];
    void(^block)(void) = ^{
        NSLog(@"调用了block, global = %d", global);
    };
    NSLog(@"%@", block);
}
结果:<__NSGlobalBlock__: 0x100934080>

static int global = 5;
- (void)viewDidLoad {
    [super viewDidLoad];
    void(^block)(void) = ^{
        NSLog(@"调用了block, global = %d", global);
    };
    NSLog(@"%@", block);
}
结果:<__NSGlobalBlock__: 0x100be8080>

__block int global = 5;//__block修饰全局变量，报错

通过代码可以看出，如果使用retain修饰block，则self.block存放在栈区。栈是由系统自动控制，则在代码块{}执行完毕后，self.block将被回收，而在touchesBegan方法中还调用self.block，报野指针错误。
然后，我们看下使用copy修饰block:

@property (copy, nonatomic) void(^block)(void);

结果:<__NSMallocBlock__: 0x28237b2d0>
触摸点击打印:调用了block, a = 3

(其他代码与上面相同)

这是因为，使用copy修饰block，self.block存储在堆区，而堆内存区域是由程序员自己控制的，因此，在viewDidLoad方法执行完毕后，self.block的内存地址并没有被回收，因此在touchesBegan方法中调用self.block();没有问题。

总结：

在MRC下
block属性必须使用copy，而不能使用retain修饰

void(^block)(void) = ^{
    NSLog(@"调用了block");
};
NSLog(@"%@", block);
结果：<__NSGlobalBlock__: 0x100b5c098>

int a = 3;//局部变量
void(^block)(void) = ^{
    NSLog(@"调用了block, a = %d", a);
};
NSLog(@"%@", block);
结果:<__NSMallocBlock__: 0x28343ea60>

__block int a = 3;
void(^block)(void) = ^{
    NSLog(@"调用了block, a = %d", a);
};
NSLog(@"%@", block);
结果:<__NSMallocBlock__: 0x2805b11d0>

static int a = 3;//static修饰局部变量
void(^block)(void) = ^{
    NSLog(@"调用了block, a = %d", a);
};
NSLog(@"%@", block);
结果:<__NSGlobalBlock__: 0x100f38098>

int global = 5;
- (void)viewDidLoad {
    [super viewDidLoad];
    void(^block)(void) = ^{
        NSLog(@"调用了block, global = %d", global);
    };
    NSLog(@"%@", block);
}
结果:<__NSGlobalBlock__: 0x100564098>

static int global = 5;
- (void)viewDidLoad {
    [super viewDidLoad];
    void(^block)(void) = ^{
        NSLog(@"调用了block, global = %d", global);
    };
    NSLog(@"%@", block);
}
结果:<__NSGlobalBlock__: 0x100b54098>

__block int global = 5;//__block修饰全局变量，报错

总结：

在ARC下
block本身是存储在全局区；
如果block引用了外部局部变量，或者引用了被__block修饰的外部局部变量，则存放在堆区。
被__block修饰的block还是局部变量；
被static修饰的局部变量，改变局部变量的声明周期。
在ARC中使用copy修饰block

@interface ViewController ()
@property (copy, nonatomic) void(^block)(void);
@end

@implementation ViewController
- (void)viewDidLoad {
    [super viewDidLoad];
    int a = 3;
    void(^block)(void) = ^{
        NSLog(@"调用了block, a = %d", a);
    };
    self.block = block;
    NSLog(@"%@", self.block);
}

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
    self.block();
}

结果:<__NSMallocBlock__: 0x28065c0f0>
触摸点击打印:调用了block, a = 3

在ARC中使用strong修饰block

@property (strong, nonatomic) void(^block)(void);

结果:<__NSMallocBlock__: 0x2802b5ef0>
触摸点击打印:调用了block, a = 3

在ARC中使用weak修饰block

@property (weak, nonatomic) void(^block)(void);

结果: <__NSMallocBlock__: 0x282cdb3c0>
触摸点击崩溃，报EXC_BAD_INSTRUCTION错误

在ARC中使用assign修饰block

在ARC下
block属性可以使用copy或者strong修饰，不能使用weak或者assign修饰
通过ARC管理机制我们知道，如果没有任何强指针引用，则对象会被清空。所以，用weak或者assign没有对block进行强指针引用，因此，在viewDidLoad方法执行完毕后，block就被清空，再次使用self.block会造成野指针错误。
在ARC下，string和block用copy还是strong?

其实两个都可以使用，但是还是建议使用strong。
string使用copy修饰，只是浅拷贝，并没有建立新的对象，所以，strong就可以满足。
block使用copy修饰，也没有新的对象创建，所以，strong就可以满足。
而，strong和copy不一样的地方在于，使用copy修饰的属性，在set方法中，会有一些列的copy操作，而strong并不需要，从性能上说，strong高一些。

Block的循环引用注意事项

block会对里面所有的外部变量对象进行强引用。

int a = 3;//局部变量
void(^block)(void) = ^{
    NSLog(@"调用了block, a = %d", a);
};
a = 4;
block();
结果：调用了block, a = 3

static int a = 3;//static修饰局部变量
结果：调用了block, a = 4

__block int a = 3;//__block修饰局部变量
结果：调用了block, a = 4

int a = 3;//全局变量
结果：调用了block, a = 4

static int a = 3;//static修饰全局变量
结果：调用了block, a = 4

总结

block调用局部变量是值传递；
使用static或者__block修饰的局部变量是指针传递；
全局变量和使用static修饰的全局变量，block没有捕获全局变量，因此，在block内部可以修改全局变量
上面的总结第三点其实是不对的，为什么呢？

为什么是这样的结果呢？？？

想了解更多的小伙伴，可以看这两篇文章，为你答疑解惑。
iOS之Block本质(一)
iOS之Block本质(二)

block作为参数

block作为参数使用，在UIView的动画里面很常见，例如：

[UIView animateWithDuration:3.0 animations:^{   
}];

其方法是：
+ (void)animateWithDuration:(NSTimeInterval)duration animations:(void (^)(void))animations

(void (^)(void))是一个参数为void，返回值为void的block类型，animations是block变量名。
可以看出，block作为参数时，使用 (block类型)block变量名 的形式定义。

我们什么时候让block作为参数使用呢？

这个可以想下，我们什么时候使用动画。
在3.0内，执行animations里面的内容，什么时候执行这个方法，是由UIView调用animateWithDuration方法决定的，至于里面要执行的什么动画，则是一个block，是一个代码块，是可以由程序员自己定义自己写的。

换言之，block代码块里面的内容是程序员保存的一端代码，写完并没有立马执行。什么时候执行呢？是由UIView调用animateWithDuration方法执行的。

举一个例子:

@interface Calculator : NSObject
@property (assign, nonatomic) int result;
//定义一个方法，参数类型是int(^)(int)，参数名是block
- (void)jisuan:(int(^)(int))block;
@end

@implementation Calculator
//方法的实现
- (void)jisuan:(int(^)(int result))block
{
    if (block) {
        //调用block，并将block调用的结果赋值给result
        _result = block(_result);
    }
}
@end

Calculator *calculator = [[Calculator alloc] init];
[calculator jisuan:^int(int result) {//block的参数名不可省略，block的返回值类型可以省略（第一个int）
    result += 5;
    result *= 2;
    return result;
}];

NSLog(@"%d", calculator.result);
结果：10

这个例子中，jisuan:方法里面的参数是一个block，当调用这个方法的时候，调用的block，执行block里面的代码。

block作为返回值

block作为返回值的经典代表就是Masonry三方框架，基本上整个框架都是使用的Block作为返回值。

拿一个简单的Masonry布局代码进行分析:

[thirdView mas_makeConstraints:^(MASConstraintMaker *make) {
        make.left.right.equalTo(bottomView);
        make.top.equalTo(_secondView.mas_bottom);
        make.height.equalTo(@70);
}];

make.left.right.equalTo(bottomView);
代码中，从前往后执行，首先是make.left，该语法是一个get方法，自动寻找是否有left方法，并返回对象本身（类型MASConstraintMaker），make.left.right以及make.left.right.equalTo都是返回对象本身（类型MASConstraintMaker），则最后是(MASConstraintMaker类型)(bottomView)。其实iMASConstraintMaker类型是一个block类型，最后的调用是对该block进行了调用，参数是bottomView。

来个简单的block作为返回值的例子:

- (void)viewDidLoad {
    [super viewDidLoad];
    self.test();
}
- (void(^)(void))test{
    //方法一：定义一个变量名为block的blocke，并返回
    void(^block)(void) = ^{
        NSLog(@"调用test函数返回block");
    };
    return block;
    
    //方法二：直接返回一个block
    return ^{
        NSLog(@"调用test函数返回block");
    };
}

结果:调用test函数返回block

接下来，我们做一个简单的连续进行加法计算的例子

@interface Calculator : NSObject
@property (assign, nonatomic) int result;
//定义一个方法，返回值是其本身
- (Calculator *)jisuanAdd:(int)value;
@end

@implementation Calculator
//方法的实现
- (Calculator *)jisuanAdd:(int)value
{
    self.result += value;
    return self;
}
@end

- (void)viewDidLoad {
    [super viewDidLoad];
    Calculator *calculator = [[Calculator alloc] init];
    [[[calculator jisuanAdd:2] jisuanAdd:5] jisuanAdd:3];
    NSLog(@"%d", calculator.result);
}

结果:10

通过上面的例子，我们可以实现连续进行加法的计算，我们对例子进行改进，使其可以跟Masonry一样，进行链式编程。

@interface Calculator : NSObject
@property (assign, nonatomic) int result;
//定义一个方法，返回值是一个block，该block是一个参数为int，返回值为Calculator的类型
- (Calculator *(^)(int))jisuanAdd;
@end

@implementation Calculator
//方法的实现
- (Calculator *(^)(int))jisuanAdd
{
	//返回一个block
    return ^(int value){
        self.result += value;
        return self;
    };
}
@end

- (void)viewDidLoad {
    [super viewDidLoad];
    Calculator *calculator = [[Calculator alloc] init];
    calculator.jisuanAdd(2).jisuanAdd(5).jisuanAdd(3);
    NSLog(@"%d", calculator.result);
}

结果:10