简介
block可以当做匿名函数，可以在两个对象间将语句当做数据来进行传递。具有封闭性closure，方便取得上下文相关状态信息。简单 block 定义就像函数指针，用^替代了*。
Block的创建
- 可以如声明函数那样声明一个block变量
- 定义函数的方法定义block
- 把block当做一个函数来调用
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可以简写为^ { … }
double (^randomPercent)(void) = ^ {
return (double)arc4random() / 4294967295;
};
NSLog(@"Gas tank is %.1f%% full”, randomPercent() * 100);
Block的闭包（closure）
block内部可以访问定义在block外部的非局部变量。非局部变量会以拷贝形式存储到block中。
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。
__block int i = 0;
int (^count)(void) = ^ {
i += 1;
return i;
};
NSLog(@"%d", count()); // 1
NSLog(@"%d", count()); // 2
NSLog(@"%d", count()); // 3
Block作为函数的参数
// 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类型
// 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 环，解决了上述的问题。
self.queue = [[NSOperationQueue alloc] init];
MyOperation *operation = [[MyOperation alloc] init];
operation.completionBlock = ^{
[self finishedOperation];
};
[self.queue addOperation:operation];
另一个解决方法
@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 定义
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定义:
<#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块外地址相同; /}
