概念
代码块block是苹果在iOS4开始引入的对C语言的扩展,用来实现匿名函数的特性,block是一种特殊的数据类型,其可以正常定义变量、作为参数、作为返回值,特殊地,block还可以保存一段代码,在需要的时候调用,目前block已经广泛应用于iOS开发中,常用于GCD、动画、排序及各类回调
block:我们称代码块,他类似一个方法。而每一个方法都是在被调用的时候从硬盘到内存,然后去执行,执行完就消失,所以,方法的内存不需要我们管理,也就是说,方法是在内存的栈区。所以,block不像OC中的类对象(在堆区),他也是在栈区的。如果我们使用block作为一个对象的属性,我们会使用关键字copy修饰他,因为他在栈区,我们没办法控制他的消亡,当我们用copy修饰的时候,系统会把该 block的实现拷贝一份到堆区,这样我们对应的属性,就拥有的该block的所有权。就可以保证block代码块不会提前消亡。
定义与使用
block 变量的声明
block 变量的声明格式:返回值类型(^block名字)(参数列表);
1
2
3
4
5
|
block 变量的声明格式:返回值类型(^block名字)(参数列表);
//声明一个无返回值,两个参数的 block
void (^block1)(NSString *a,NSString *b);
//省略写法
void (^block2)(NSString *,NSString *);
|
block变量的赋值
1
2
3
4
5
6
|
//block变量的赋值
//block变量名 = ^(参数列表){函数体};
block1 = ^(NSString *x,NSString *y){
NSLog(@ "%@--%@" ,x,y);
};
block1(@ "123123" ,@ "QWEQWEQWE" );
|
声明block变量的同时进行赋值
1
2
3
4
5
|
//声明 block 变量的同时进行赋值
int (^block3)( int ) = ^( int a){
return a*3;
};
NSLog(@ "%d" ,block3(3));
|
使用typedef定义block类型
在实际使用Block的过程中,我们可能需要重复地声明多个相同返回值相同参数列表的Block变量,如果总是重复地编写一长串代码来声明变量会非常繁琐,所以我们可以使用typedef来定义Block类型
1
2
3
4
5
6
7
|
#pragma mark 使用 typedef 定义 block 类型
//定义一个无返回值类型 无参数列表的 block
typedef void (^Block4)();
Block4 block4 = ^(){
NSLog(@ "i am block4" );
};
block4();
|
block作为函数参数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
#pragma mark block作为函数参数
int (^block5)( int , int ) = ^( int a, int b){
return a+b;
};
[self useBlock5:block5];
//简化书写
//typedef int (^Block6)(int,int);(全局声明)
Block6 block6 = ^( int a, int b){
return a+b;
};
[self useBlock6:block6];
- ( void )useBlock5:( int (^)( int , int ))block5 {
NSLog(@ "block5:%d" ,block5(3,5));
}
- ( void )useBlock6:(Block6 )block6{
NSLog(@ "block6:%d" ,block6(4,5));
}
|
block内访问局部变量
- 在Block中可以访问局部变量
- 在声明Block之后、调用Block之前对局部变量进行修改,在调用Block时局部变量值是修改之前的旧值
- 在Block中不可以直接修改局部变量
1
2
3
4
5
6
7
8
|
#pragma mark block -----------访问局部变量
//block 中不可以直接修改局部变量
int value1 = 100;
void (^block7)( void ) = ^(){
NSLog(@ "value1:%d" ,value1);
};
value1 = 200;
block7(); //输出100
|
- 在局部变量前使用下划线下划线block修饰,在声明Block之后、调用Block之前对局部变量进行修改,在调用Block时局部变量值是修改之后的新值
- 在局部变量前使用下划线下划线block修饰,在Block中可以直接修改局部变量
1
2
3
4
5
6
7
8
9
10
|
#pragma mark block -----------访问局部变量
//block 中不可以直接修改局部变量
//在局部变量前使用__block修饰,在Block中可以直接修改局部变量
__block int value1 = 100;
void (^block7)( void ) = ^(){
value1++;
NSLog(@ "value1:%d" ,value1);
};
value1 = 200;
block7(); //输出100 __block 修饰之后输出200
|
block内访问全局变量
在声明Block之后、调用Block之前对全局变量进行修改,在调用Block时全局变量值是修改之后的新值
1
2
3
4
5
6
7
8
9
10
|
#pragma mark ------------------block 访问全局变量
//在Block中可以访问全局变量
value2 = 100;
void (^block8)( void ) = ^(){
//在Block中可以直接修改全局变量
self->value2++;
NSLog(@ "value2:%d" ,self->value2);
};
value2 = 200;
block8();
|
block内访问静态变量
1
2
3
4
5
6
7
8
9
|
#pragma mark --------block内访问静态变量
static int value3 = 100;
void (^block9)( void ) = ^(){
value3++; //在Block中可以直接修改静态变量
NSLog(@ "value3:%d" ,value3);
};
//在声明Block之后、调用Block之前对静态变量进行修改,在调用Block时静态变量值是修改之后的新值
value3 = 200;
block9();
|
block 造成的循环引用问题
如果对象内部有一个Block属性,而在Block内部又访问了该对象,那么会造成循环引用
情况一
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
|
@interface Person : NSObject
@property (nonatomic, copy) void (^myBlock)();
@end
@implementation Person
- ( void )dealloc
{
NSLog(@ "Person dealloc" );
}
@end
Person *p = [[Person alloc] init];
p.myBlock = ^{
NSLog(@ "------%@" , p);
};
p.myBlock();
// 因为myBlock作为Person的属性,采用copy修饰符修饰(这样才能保证Block在堆里面,以免Block在栈中被系统释放),所以Block会对Person对象进行一次强引用,导致循环引用无法释放
|
情况二
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
|
@interface Person : NSObject
@property (nonatomic, copy) void (^myBlock)();
- ( void )resetBlock;
@end
@implementation Person
- ( void )resetBlock
{
self.myBlock = ^{
NSLog(@ "------%@" , self);
};
}
- ( void )dealloc
{
NSLog(@ "Person dealloc" );
}
@end
Person *p = [[Person alloc] init];
[p resetBlock];
// Person对象在这里无法正常释放,在resetBlock方法实现中,Block内部对self进行了一次强引用,导致循环引用无法释放
|
解决循环引用的办法是使用一个弱引用的指针指向该对象,然后在Block内部使用该弱引用指针来进行操作,这样避免了Block对对象进行强引用
情况一
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
|
@interface Person : NSObject
@property (nonatomic, copy) void (^myBlock)();
@end
@implementation Person
- ( void )dealloc
{
NSLog(@ "Person dealloc" );
}
@end
Person *p = [[Person alloc] init];
__weak typeof(p) weakP = p;
p.myBlock = ^{
NSLog(@ "------%@" , weakP);
};
p.myBlock();
// Person对象在这里可以正常被释放
|
情况二
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
|
@interface Person : NSObject
@property (nonatomic, copy) void (^myBlock)();
- ( void )resetBlock;
@end
@implementation Person
- ( void )resetBlock
{
// 这里为了通用一点,可以使用__weak typeof(self) weakP = self;
__weak Person *weakP = self;
self.myBlock = ^{
NSLog(@ "------%@" , weakP);
};
}
- ( void )dealloc
{
NSLog(@ "Person dealloc" );
}
@end
Person *p = [[Person alloc] init];
[p resetBlock];
// Person对象在这里可以正常被释放
|
总结
以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作具有一定的参考学习价值,谢谢大家对服务器之家的支持。
原文链接:https://segmentfault.com/a/1190000018616920