suwang Tech Blog

Tech Blog

0%

iOS block

发表于 更新于

简介

block可以当做匿名函数，可以在两个对象间将语句当做数据来进行传递。具有封闭性closure，方便取得上下文相关状态信息。简单 block 定义就像函数指针，用^替代了*。

Block的创建

  • 可以如声明函数那样声明一个block变量
  • 定义函数的方法定义block
  • 把block当做一个函数来调用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int main(int argc, const char * argv[]) {
     @autoreleasepool {
     // Declare the block variable
     double (^distanceFromRateAndTime)(double rate, double time);
     // Create and assign the block
     distanceFromRateAndTime = ^double(double rate, double time) {
          return rate * time;
     };
     // Call the block
     double dx = distanceFromRateAndTime(35, 1.5);
     NSLog(@"A car driving 35 mph will travel "
          @"%.2f miles in 1.5 hours.", dx);
     }
     return 0;
}

不带参数的Block

block可以简写为^ { … }

1
2
3
4
5
double (^randomPercent)(void) = ^ {
     return (double)arc4random() / 4294967295;
};
NSLog(@"Gas tank is %.1f%% full”, randomPercent() * 100);

Block的闭包（closure）

block内部可以访问定义在block外部的非局部变量。非局部变量会以拷贝形式存储到block中。

1
2
3
4
5
6
7
8
NSString *make = @"Honda";
NSString *(^getFullCarName)(NSString *) = ^(NSString *model) {
     return [make stringByAppendingFormat:@" %@", model];
};
NSLog(@"%@", getFullCarName(@"Accord")); // Honda Accord
// Try changing the non-local variable (it won't change the block)
make = @"Porsche";
NSLog(@"%@", getFullCarName(@"911 Turbo")); // Honda 911 Turbo

修改非局部变量

用block存储修饰符号（storage modifier）声明非局部变量，默认情况下，在程序块中访问的外部变量是复制过去的，即写操作不会对原变量生效。但是你可以加上block 来让其写操作生效。对于 block 外的变量引用，如果对象是引用类型，则 block 会将其引用计数加1。

1
2
3
4
5
6
7
8
__block int i = 0;
int (^count)(void) = ^ {
     i += 1;
     return i;
};
NSLog(@"%d", count()); // 1
NSLog(@"%d", count()); // 2
NSLog(@"%d", count()); // 3

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
// Car.h
#import
@interface Car : NSObject
@property double odometer;
- (void)driveForDuration:(double)duration
     withVariableSpeed:(double (^)(double time))speedFunction
     steps:(int)numSteps;
@end
//调用block
// Car.m
#import "Car.h"
@implementation Car
@synthesize odometer = _odometer;
- (void)driveForDuration:(double)duration
     withVariableSpeed:(double (^)(double time))speedFunction
     steps:(int)numSteps {
     double dt = duration / numSteps;
     for (int i=1; i<=numSteps; i++) {
          _odometer += speedFunction(i*dt) * dt;
     }
}
@end
//在main函数中block定义在另一个函数的调用过程中。
// main.m
#import
#import "Car.h"
int main(int argc, const char * argv[]) {
     @autoreleasepool {
          Car *theCar = [[Car alloc] init];
          // Drive for awhile with constant speed of 5.0 m/s
          [theCar driveForDuration:10.0
               withVariableSpeed:^(double time) {
               return 5.0;
               } steps:100];
          NSLog(@"The car has now driven %.2f meters", theCar.odometer);
          // Start accelerating at a rate of 1.0 m/s^2
          [theCar driveForDuration:10.0
               withVariableSpeed:^(double time) {
               return time + 5.0;
               } steps:100];
          NSLog(@"The car has now driven %.2f meters", theCar.odometer);
     }
     return 0;
}

定义Block类型

1
2
3
4
5
6
7
8
9
10
// Car.h
#import
// Define a new type for the block
typedef double (^SpeedFunction)(double);
@interface Car : NSObject
@property double odometer;
- (void)driveForDuration:(double)duration
     withVariableSpeed:(SpeedFunction)speedFunction
     steps:(int)numSteps;
@end

风险

block会存在导致retain cycles的风险，如果发送者需要 retain block 但又不能确保引用在什么时候被赋值为 nil， 那么所有在 block 内对 self 的引用就会发生潜在的 retain 环。NSOperation 是使用 block 的一个好范例。因为它在一定的地方打破了 retain 环，解决了上述的问题。

1
2
3
4
5
6
self.queue = [[NSOperationQueue alloc] init];
MyOperation *operation = [[MyOperation alloc] init];
operation.completionBlock = ^{
     [self finishedOperation];
};
[self.queue addOperation:operation];

另一个解决方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@interface Encoder ()
@property (nonatomic, copy) void (^completionHandler)();
@end
@implementation Encoder
- (void)encodeWithCompletionHandler:(void (^)())handler
{
     self.completionHandler = handler;
     // 进行异步处理...
}
// 这个方法会在完成后被调用一次
- (void)finishedEncoding
{
     self.completionHandler();
     self.completionHandler = nil; //一旦任务完成就设置为nil
}
@end

#block 定义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
struct Block_descriptor {
    unsigned long int reserved;
    unsigned long int size;
    void (*copy)(void *dst, void *src);
    void (*dispose)(void *);
};
struct Block_layout {
    void *isa;
    int flags;
    int reserved; 
    void (*invoke)(void *, ...);
    struct Block_descriptor *descriptor;
    /* Imported variables. */
};

在Xcode里输入inlineblock可以快速补全block定义:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<#returnType#> (^<#blockName#>) (<#parameterTypes#>) = ^ (<#parameters#>) { <#statements#> };

returnType : 返回值类型
blockName  : block命名
parameterTypes : 参数类型
parameters : 参数
声明block使用 <#returnType#> (^<#blockName#>) (<#parameterTypes#>);

如: @property (copy, nonatomic) void (^block)(int);
^(<#参数#>){


// 在Block中, 如果只使用全局或静态变量或不使用外部变量, 那么Block块的代码会存储在全局区;
如果使用了外部变量, 在ARC中, Block块的代码会存储在堆区;
在MRC中, Block块的代码会存储在栈区;
block默认情况下不能修改外部变量, 只能读取外部变量:
在ARC中, 外部变量存在堆中, 这个变量在Block块内与Block块外地址相同;
外部变量存在栈中, 这个变量会被转移到堆区, 不是复制, 是转移.
在MRC中, 外部变量存在堆中, 这个变量在Block块内与Block块外地址相同; 外部变量存在栈中, 这个变量在Block块内与Block块外地址相同; /}