本文详细介绍了ReactiveCocoa框架，它是具备函数式编程思想的开发框架，能统一简化苹果原生框架操作。还阐述了RAC相关知识点，包括聚合信号、控件事件、副作用等，以及核心信号、信号家族、封装信号等内容，涉及信号的创建、订阅、转换、拼接等操作。
RAC知识点
1、 RACSignal发送事件流给它的subscribe.目前总共有三种类型的事件:next error completed.一个signal在因error终止或者完成前,可以发送任意数量的next事件
2、 RACSignal的每个操作都会返回一个RACSignal(返回的信号是新创建的,与上一个信号不是相同实例),这叫做连贯接口(fluent interface).这个功能可以让你直接构建管道,而不用每一步都使用本地变量
3、 map: 接收上一次的next事件返回值,可以根据需要修改该值,并把修改后的值传递给下一个next事件
4、 filter: 根据接收的事件返回值,判断是否继续往后传递事件
5、 subscribeNext: 事件的订阅者,每次next事件发生时,subscribeNext:方法提供的block都会执行
6、 RAC宏:允许直接把信号的输出应用到对象的属性上.RAC宏有两个参数,第一个是需要设置属性值得对象.第二个是属性名.每次信号产生一个Next事件,传递过来的值都会应用到该属性上
7、 RACObserve宏:监听属性变化的RACObserve(TARGET, KEYPATH) // TARGET:监听目标 KEYPATH:目标属性
聚合信号
1、 RACSignal的这个方法可以聚合任意数量的信号,reduce block的参数和每个源信号相关.ReactiveCoco有一个工具类RACBlockTrampoline,它在内部处理reduce block的可变参数
代码示例:
+ (RACSignal *)combineLatest:(id<NSFastEnumeration>)signals reduce:(id (^)())reduceBlock
文中实例
[RACSignal combineLatest:@[validUsernameSignal, validPasswordSignal]
reduce:^id(NSNumber *usernameValid, NSNumber *passwordValid) {
return @([usernameValid boolValue] && [passwordValid boolValue]);
}];
注：这个聚合信号如果没有订阅者，不会执行reduce的block。
2、 一个信号可以有多个订阅者(分隔),多个信号可以聚合为一个新的信号.
控件事件
1、文本事件 rac_textSignal
2、按钮事件 rac_signalForControlEvents
副作用(Adding side-effects)
1、 doNext:用于执行一些事情发生时的附加操作.不影响事件本身,如UI变化,它的block无返回值.
2、 flattenMap 用于将当前外部信号中的内部信号的事件传递给下一个外部信号
ReactiveCocoa
概念：
1、Reactive:响应式的、函数式的
2、Cocoa:苹果开发框架名称
3、Reactive+Cocoa:具备函数式编程思想的开发框架
为什么要用ReactiveCocoa？
1、统一简化了苹果原生框架大多场景,提高开发效率
2、统一ios原生中常用的Target、Delegate、KVO、通知、NSTimer、网络异步回调等操作,并将响应的事件处理代码聚合一起
第一:基础概念
1、核心是携带信息的信号进行传递和订阅的过程
2、示意图：
3、与之相关的四个大的概念
- 1.信号源
- 2.订阅者
- 3.回收站(RACDisposable)
- 4.调度器
信号源
1、信号的老祖宗RACStream,指的是信号流,其继承结构如图:
通常情况下不直接使用RACStream,而是使用其子类进行信号传递
- 核心类RACSignal
- 最常用的信号类,.主要功能是创建信号、配置订阅者来订阅信号
- 信号在传递过程中包括正常传递、传递完成、传递失败的状态,分别为:Next、completed、error
- 如图：
- 序列信号RACSequence
- 简化OC中的集合操作的信号类
2.订阅者
- 为了获取某个信号源中的值,通常需要对该信号源进行订阅,这就产生了订阅者的概念
- 在ReactiveCocoa中所有实现了RACSubscriber协议的类都可以作为信号源的订阅者
- RACSubscribe协议规定实现的四个方法:
@protocol RACSubscriber <NSObject>
@required
- (void)sendNext:(id)value;
- (void)sendError:(NSError *)error;
- (void)sendCompleted;
- (void)didSubscribeWithDisposable:(RACCompoundDisposable *)disposable;
@end
- 其中 -sendNext:、-sendError: 和 -sendComplete方法分别是接收信号Next、error和complete事件; -didSubscribeWithDIsposable:方法用来接收代表某次订阅的RACDisposable(回收站)对象
3.回收站(RACDisposable)
- 在ReactiveCocoa中并没有专门的类来代表一次完整的订阅行为，而间接地使用RACDisposable来表示订阅行为。
- 订阅完成或失败时自动触发回收机制，因为它主要做一些资源回收和垃圾清理的工作。
- 可以通过RACDisposable的 ==dispose== 方法主动取消订阅行为，不再接受信号传递的信息
4.调度器(RACScheduler)
- RACScheduler是对GCD的简单封装,用来调度订阅任务
第二:核心信号之RACSignal
- 创建、订阅、发送、回收信号
- 代码示例:
- (void)testCreateSignal {
// 1.创建信号
RACSignal *siganl = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
// 每当有订阅者订阅信号，就会调用此block。
// 3.发送信号
[subscriber sendNext:@"糖水"];
[subscriber sendNext:@"盐水"];
[subscriber sendNext:@"辣椒水"];
// 如果不再发送数据，最好发送信号完成，内部会自动调用[RACDisposable disposable]取消订阅信号。
// 5.订阅完成
[subscriber sendCompleted];
return [RACDisposable disposableWithBlock:^{
// 7.当信号发送完成或者发送错误，就会自动执行这个block,取消订阅信号。
// 执行完Block后，当前信号就不在被订阅了。
NSLog(@"信号被销毁");
}];
}];
// 2.订阅信号,依次获取步骤3中传递的信息
// (此方法隐藏了两件事：一是创建订阅者RACSubscriber，二是为信号配置订阅者并触发订阅任务。其目的是简化信号订阅逻辑)
[siganl subscribeNext:^(id x) {
// 4.每当有信号sendNext: ，就会调用此block.
NSLog(@"接收到数据:%@",x);
} error:^(NSError *error) {
NSLog(@"信号发送失败");
} completed:^{
// 6.第5步中[subscriber sendCompleted];执行后直接走此处方法
NSLog(@"信号发送完成");
}];
// 8.继续订阅信号，依次获取步骤3中传递的信息
[siganl subscribeNext:^(id x) {
// 每当有信号sendNext: ，就会调用此block.
NSLog(@"接收到数据:%@",x);
}];
}
// 最终控制台输出结果为:
2017-06-23 16:15:49.027 RACDemo[48262:2367413] 第一个订阅者接收到:糖水
2017-06-23 16:15:49.027 RACDemo[48262:2367413] 第一个订阅者接收到:盐水
2017-06-23 16:15:49.027 RACDemo[48262:2367413] 第一个订阅者接收到:辣椒水
2017-06-23 16:15:49.028 RACDemo[48262:2367413] 信号发送完成
2017-06-23 16:15:49.028 RACDemo[48262:2367413] 信号被销毁
2017-06-23 16:15:49.028 RACDemo[48262:2367413] 第二个订阅者接收到:糖水
2017-06-23 16:15:49.028 RACDemo[48262:2367413] 第二个订阅者接收到:盐水
2017-06-23 16:15:49.028 RACDemo[48262:2367413] 第二个订阅者接收到:辣椒水
2017-06-23 16:15:49.029 RACDemo[48262:2367413] 信号被销毁
解读
- 对于信号创建、订阅、发送、回收,我们可以把整个ReactiveCocoa框架形象的类比为水管管道机制,如下图:
华丽的信号家族之RACSubject
- 上图描述的是一般的信号传递机制,华丽版的信号传递无非是在此基础上,修改,调整水阀之间的连通关系
1.RACSubject
- RACSubject与RACSignal做大不同的是,RACSubject既是信号的子类,同时也能实现订阅信号着的RACSubscriber协议,因此也可以充当订阅者发送消息
- 示例代码:
- (void)testRACSubject {
// RACSubject使用步骤
// 1.创建信号 [RACSubject subject]，跟RACSiganl不一样，创建信号时没有block。
// 2.订阅信号 - (RACDisposable *)subscribeNext:(void (^)(id x))nextBlock
// 3.发送信号 sendNext:(id)value
// RACSubject:底层实现和RACSignal不一样。
// 1.调用subscribeNext订阅信号，只是把订阅者保存起来，并且订阅者的nextBlock已经赋值了。
// 2.调用sendNext发送信号，遍历刚刚保存的所有订阅者，一个一个调用订阅者的nextBlock。
// 1.创建信号
RACSubject *subject = [RACSubject subject];
// 2.订阅信号
[subject subscribeNext:^(id x) {
// block调用时刻：当信号发出新值，就会调用.
NSLog(@"第一个订阅者%@",x);
}];
[subject subscribeNext:^(id x) {
// block调用时刻：当信号发出新值，就会调用.
NSLog(@"第二个订阅者%@",x);
}];
// 3.发送信号
[subject sendNext:@"糖水"];
[subject sendNext:@"盐水"];
[subject sendNext:@"辣椒水"];
}
// 最终控制台输出结果为:
2017-06-23 16:12:13.565 RACDemo[48194:2363636] 第一个订阅者接收到:糖水
2017-06-23 16:12:13.566 RACDemo[48194:2363636] 第二个订阅者接收到:糖水
2017-06-23 16:12:13.566 RACDemo[48194:2363636] 第一个订阅者接收到:盐水
2017-06-23 16:12:13.566 RACDemo[48194:2363636] 第二个订阅者接收到:盐水
2017-06-23 16:12:13.566 RACDemo[48194:2363636] 第一个订阅者接收到:辣椒水
2017-06-23 16:12:13.566 RACDemo[48194:2363636] 第二个订阅者接收到:辣椒水
解读
- 首先写法上, sendNext:不用挤在信号创建的block中写,RACSubject对象本身可以作为订阅者调用此方法
- 其次RACSubject的订阅方法( subscribeNext: )仅仅是接收者
- sendNext:会把信号传递给所有的 subscribeNext:
- RACSubject和RACSignal最大的不同点在于发送信号的时机,前者是配置好发送信号的出口,如图:
2.RACReplaySubject
- 代码:
- (void)testRACReplaySubject {
// RACReplaySubject:底层实现和RACSubject不一样。
// 1.调用sendNext发送信号，把值保存起来，然后遍历刚刚保存的所有订阅者，一个一个调用订阅者的nextBlock。
// 2.调用subscribeNext订阅信号，遍历保存的所有值，一个一个调用订阅者的nextBlock
// 如果想当一个信号被订阅，就重复播放之前所有值，需要先发送信号，在订阅信号。
// 也就是先保存值，在订阅值。
// 1.创建信号
RACReplaySubject *replaySubject = [RACReplaySubject subject];
// 2.发送信号
[replaySubject sendNext:@"糖水"];
[replaySubject sendNext:@"盐水"];
[replaySubject sendNext:@"辣椒水"];
// 3.订阅信号
[replaySubject subscribeNext:^(id x) {
NSLog(@"第一个订阅者接收到:%@",x);
}];
// 订阅信号
[replaySubject subscribeNext:^(id x) {
NSLog(@"第一个订阅者接收到:%@",x);
}];
}
// 最终控制台输出结果为:
2017-06-26 17:52:39.670 RACDemo[61435:3788527] 第一个订阅者接收到:糖水
2017-06-26 17:52:39.671 RACDemo[61435:3788527] 第一个订阅者接收到:盐水
2017-06-26 17:52:39.671 RACDemo[61435:3788527] 第一个订阅者接收到:辣椒水
2017-06-26 17:52:39.671 RACDemo[61435:3788527] 第二个订阅者接收到:糖水
2017-06-26 17:52:39.671 RACDemo[61435:3788527] 第二个订阅者接收到:盐水
2017-06-26 17:52:39.672 RACDemo[61435:3788527] 第二个订阅者接收到:辣椒水
解读
- 输出的结果跟RACSignal完全一致,只是写法上略有不同
- 继承RACSubject的RACReplaySubject实现了基本信号功能
- RACReplaySubject还可以在上面的订阅代码后面,继承发送信号 sendNext: ,实现和RACSubject一样的功能
- 如图所示:
- 总结:RACSubject实现每个信号群到所有信号发送口,RACReplaySubject实现每个信号发送口接收所有的信号
3.RACMulticastConnection
- 代码示例:
- (void)testRACMulticastConnection {
// RACMulticastConnection使用步骤:
// 1.创建信号 + (RACSignal *)createSignal:(RACDisposable * (^)(id<RACSubscriber> subscriber))didSubscribe
// 2.创建连接 RACMulticastConnection *connect = [signal publish];
// 3.订阅信号,注意：订阅的不在是之前的信号，而是连接的信号。 [connect.signal subscribeNext:nextBlock]
// 4.连接 [connect connect]
// RACMulticastConnection底层原理:
// 1.创建connect，connect.sourceSignal -> RACSignal(原始信号) connect.signal -> RACSubject
// 2.订阅connect.signal，会调用RACSubject的subscribeNext，创建订阅者，而且把订阅者保存起来，不会执行block。
// 3.[connect connect]内部会订阅RACSignal(原始信号)，并且订阅者是RACSubject
// 3.1.订阅原始信号，就会调用原始信号中的didSubscribe
// 3.2 didSubscribe，拿到订阅者调用sendNext，其实是调用RACSubject的sendNext
// 4.RACSubject的sendNext,会遍历RACSubject所有订阅者发送信号。
// 4.1 因为刚刚第二步，都是在订阅RACSubject，因此会拿到第二步所有的订阅者，调用他们的nextBlock
// 需求：假设在一个信号中发送请求，每次订阅一次都会发送请求，这样就会导致多次请求。
// 解决：使用RACMulticastConnection就能解决.
// RACMulticastConnection:解决重复请求问题
// 1.创建信号
RACSignal *signal = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
NSLog(@"发送请求");
[subscriber sendNext:@"糖水"];
[subscriber sendNext:@"盐水"];
[subscriber sendNext:@"辣椒水"];
return nil;
}];
// 2.创建连接
RACMulticastConnection *connect = [signal publish];
// 3.订阅信号，
// 注意：订阅信号，也不能激活信号，只是保存订阅者到数组，必须通过连接,当调用连接，就会一次性调用所有订阅者的sendNext:
[connect.signal subscribeNext:^(id x) {
NSLog(@"第一个订阅者接收到:%@",x);
}];
[connect.signal subscribeNext:^(id x) {
NSLog(@"第二个订阅者接收到:%@",x);
}];
// 4.连接,激活信号
[connect connect];
}
// 最终控制台输出结果为:
2017-06-26 18:44:55.057 RACDemo[61893:3825826] 发送请求
2017-06-26 18:44:55.058 RACDemo[61893:3825826] 第一个订阅者接收到:糖水
2017-06-26 18:44:55.058 RACDemo[61893:3825826] 第二个订阅者接收到:糖水
2017-06-26 18:44:55.058 RACDemo[61893:3825826] 第一个订阅者接收到:盐水
2017-06-26 18:44:55.058 RACDemo[61893:3825826] 第二个订阅者接收到:盐水
2017-06-26 18:44:55.058 RACDemo[61893:3825826] 第一个订阅者接收到:辣椒水
2017-06-26 18:44:55.059 RACDemo[61893:3825826] 第二个订阅者接收到:辣椒水
解读
- RACMulticastConnection的庐山真面目就是RACSubject订阅机制
第四:封装好的简单信号
- 1)监听是否实现了某个方法之 rac_signalForSelector
- 应用场景:判断某个代理是否实现某方法,或者监控某个按钮所在VC是否实现了点击方法
if ([self rac_signalForSelector:@selector(clickTestButton:)]) {
NSLog(@"点击了测试按钮");
}
- 2)替代KVO的 rac_valuesAndChangesForPath
[[self rac_valuesAndChangesForKeyPath:@"testNum"
options:NSKeyValueObservingOptionNew observer:nil] subscribeNext:^(id x) {
NSLog(@"new value info is %@", x);
}];
- 3)监听事件 rac_signalForControlEvents,如点击事件.
[[self.testButton rac_signalForControlEvents:UIControlEventTouchUpInside]
subscribeNext:^(id x) {
NSLog(@"已经实现点击事件");
}];
- 4)监听通知 rac_addObserverForName ,如键盘弹起的通知
[[[NSNotificationCenter defaultCenter]
rac_addObserverForName:UIKeyboardWillShowNotification object:nil]
subscribeNext:^(id x) {
NSLog(@"键盘弹出");
}];
- 5)手势信号之 rac_gestureSignal
UIPanGestureRecognizer *panGesture = [[UIPanGestureRecognizer alloc] init];
[panGesture.rac_gestureSignal subscribeNext:^(id x) {
NSLog(@"拖动手势:%@", x);
}];
[self.view addGestureRecognizer:panGesture];
- 6)UITextfield或UITextView文字信号之 rac_textSignal
[_textField.rac_textSignal subscribeNext:^(id x) {
NSLog(@"当前文字:%@", x);
}];
第五: 升级篇
- RACSequence
- RACCommand
- RACSchedule
- RACChannel
- 信号转换
- 信号拼接
- RAC常用宏
1.RACSequence
- 为了简化OC代码中的集合类操作
- 代码示例:
- (void)testRACSequence {
// 1.遍历数组
NSArray *numbers = @[@1, @2, @3, @4];
// 这里其实是三步
// 第一步: 把数组转换成集合RACSequence，即numbers.rac_sequence
// 第二步: 把集合RACSequence转换RACSignal信号类,numbers.rac_sequence.signal
// 第三步: 订阅信号，激活信号，会自动把集合中的所有值，遍历出来。
[numbers.rac_sequence.signal subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
// 2.遍历字典,遍历出来的键值对会包装成RACTuple(元组对象)
NSDictionary *dict = @{@"name":@"ABC",@"age":@22};
// 下面RACTuple元组的概念请自行查阅
[dict.rac_sequence.signal subscribeNext:^(RACTuple *x) {
// 解包元组，会把元组的值，按顺序给参数里面的变量赋值
RACTupleUnpack(NSString *key,NSString *value) = x;
// 相当于以下写法
// NSString *key = x[0];
// NSString *value = x[1];
NSLog(@"%@ %@", key, value);
}];
2.RACCommand
- RACCommand是一个可以包裹一个信号,并对信号的执行,完成,失败状态进行把控的类,通常把异步网络请求封装成信号的形式,然后通过RACCommand包裹信号,实时反馈网络请求状态(请求中、请求成功、请求失败).
- 模拟网络请求,代理示例:
/// 先在当前VC中添加属性:
@interface ViewController ()
@property (nonatomic, strong) RACCommand *command;
@end
/// 实现文件里写入此示例代码
- (void)testRACCommand {
if (!_command) {
_command = [[RACCommand alloc] initWithSignalBlock:^RACSignal *(id input) {
return [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
NSLog(@"开始请求网络");
// 假装请求到数据
[subscriber sendNext:@"请求到的数据"];
// 请求完成
[subscriber sendCompleted];
return [RACDisposable disposableWithBlock:^{
NSLog(@"订阅过程完成");
}];
}];
}];
// 监控是否执行中状态
[_command.executing subscribeNext:^(id x) {
NSNumber *executing = (NSNumber *)x;
NSString *stateStr = executing.boolValue? @"请求状态" : @"未请求状态";
NSLog(@"%@", stateStr);
}];
// 监控请求成功的状态
[_command.executionSignals.switchToLatest subscribeNext:^(id x) {
NSLog(@"请求成功后，拿到数据: %@", x);
}];
// 监控请求失败的状态
[_command.errors subscribeNext:^(id x) {
NSLog(@"请求失败: %@", x);
}];
}
// 执行操作 调用上面createSignal中的block操作
[_command execute:nil];
}
打印结果为:
2017-06-27 17:10:21.672 RACDemo[65799:6318742] 未请求状态
2017-06-27 17:10:21.680 RACDemo[65799:6318742] 请求状态
2017-06-27 17:10:21.681 RACDemo[65799:6318742] 开始请求网络
2017-06-27 17:10:21.681 RACDemo[65799:6318742] 请求成功后，拿到数据: 请求到的数据
2017-06-27 17:10:21.682 RACDemo[65799:6318742] 订阅过程完成
2017-06-27 17:10:21.682 RACDemo[65799:6318742] 未请求状态
解读
- 这里RACCommand的创建使用 initWithSignalBlock: 方法,其参数带一个参数并返回信号的block,因此直接在后面返回一个信号即可
- 创建完RACCommand后,就可以用RACCommand的相关属性看当前signal的状态
- 不同于使用信号订阅的三种状态 subscribeNext:、subscribeError: 和 subscribeCompleted这里用RACCommand的"executionSignal"属性代表成功拿到发送的信号,"error"属性表示失败信号.
- 在执行 [_command execute:nil]前,RACCommand的executing属性默认为NO,一旦执行,executing属性会变成YES状态,直到 sendCompleted 或 sendError情况时,executing属性再次变成NO.
- 由于RACCommand对信号执行状态多了更细致的描述，因此往往适用于异步的操作，如网络请求这种需要在请求状态时展示HUD、请求成功时隐藏HUD、请求成功的数据用来刷新视图的场景，统统可以写到一块一并被处理。
- 这里的代码只是模拟了网络请求，真正开发时需要封装现有的网络请求框架，在请求到数据、请求失败和请求成功时加入" sendNext:"、" sendError: "和" sendCompleted"代码
3.RACSchedule
- RACSchedule是对GCD的一层封装,管理信号的线程任务,其原理建议参考ReactiveCocoa 中 RACScheduler是如何封装GCD的,注意其中deliverOn方法的描述.
4.RACChannel
- 主要用于RACChannel的子类RACChannelTerminal来实现UI和属性双向绑定功能,即UI变化属性随着变化,属性变化UI也跟随变化
- 代码示例:
@interface ViewController ()
@property (weak, nonatomic) IBOutlet UITextField *textField; // 输入框
@property (nonatomic, copy) NSString *stringText; // 输入框显示的文字
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
RACChannelTerminal *textFieldChannelT = self.textField.rac_newTextChannel;
// 输入框文本变化反应到stringText属性上
RAC(self, stringText) = textFieldChannelT;
// stringText属性对应的文字订阅到输入框上 这样就实现了双向绑定
[RACObserve(self, stringText) subscribe:textFieldChannelT];
}
扩展
- NSUserDefaults之 rac_channelTerminalForKey:
- UIDatePicker之 rac_newDateChannelWithNilValue:
- UISegmentedControl之 rac_newSelectedSegmentIndexChannelWithNilValue:
- UISlider之 rac_newValueChannelWithNilValue:
5.RAC常用宏
- RAC(TARGET, [KEYPATH, [NIL_VALUE]])常用于给某个对象的某个属性绑定信号值
- 代码示例:
// 每当textField文本变化时，就会把文本信息传递给self的textFieldText属性
RAC(self, textFieldText) = [self.textField.rac_textSignal takeUntil:self.rac_willDeallocSignal];
- RACObserve(TARGET, KEYPATH)监听某个对象的某个属性,一旦属性值发生变化，立马激活信号。
- 代码示例:
如前面KVO的例子：
[[self rac_valuesAndChangesForKeyPath:@"testNum"
options:NSKeyValueObservingOptionNew observer:nil] subscribeNext:^(id x) {
NSLog(@"new value info is %@", x);
}];
使用此宏可以改写为:
[RACObserve(self, testNum) subscribeNext:^(id x) {
NSLog(@"new value is %@", x);
}];
- @weakify(obj) 和 @strongify(obj) 为避免Block循环引用而生的一对宏
//通常，blobk引用其外部变量，为避免持有外部对象，通常使用这一对宏来避免,如
@weakify(self);
[RACObserve(self, testNum) subscribeNext:^(id x) {
@strongify(self);
NSLog(@"new value is %@", self.x);
}];
- RACTurplePack 和 RACTupleUnpack 分别代表打包生成元组 和 解包分解元组。
// RACTuplePack生成元组
RACTuple *tuple = RACTuplePack(@"数据1", @2);
// RACTupleUnpack分解元组 参数:被解析的变量名
RACTupleUnpack(NSString *str, NSNumber *num) = tuple;
NSLog(@"%@ %@", str, num);
- RACChannelTo 双向绑定终端
一般情况下，使用RACChannelTo(self, name) = RACChannelTo(self.model, name);即可完成双向等值绑定功能，即一方变化另一方也跟随变化，但前提是触发属性的KVO机制才能实现。
二般情况下，举个栗子：
//首先在VC中添加两个属性:
@property (nonatomic, copy) NSString *valueA;
@property (nonatomic, copy) NSString *valueB;
// 然后添加测试方法
- (void)testRACChannelTo:(id)sender {
RACChannelTerminal *channelA = RACChannelTo(self, valueA);
RACChannelTerminal *channelB = RACChannelTo(self, valueB);
[[channelA map:^id(NSString *value) {
if ([value isEqualToString:@"西"]) {
return @"东";
}
return value;
}] subscribe:channelB];
[[channelB map:^id(NSString *value) {
if ([value isEqualToString:@"左"]) {
return @"右";
}
return value;
}] subscribe:channelA];
[[RACObserve(self, valueA) filter:^BOOL(id value) {
return value ? YES : NO;
}] subscribeNext:^(NSString* x) {
NSLog(@"你向%@", x);
}];
[[RACObserve(self, valueB) filter:^BOOL(id value) {
return value ? YES : NO;
}] subscribeNext:^(NSString* x) {
NSLog(@"他向%@", x);
}];
self.valueA = @"西";
self.valueB = @"左";
}
输出结果为:
2017-06-30 17:19:50.125 RACDemo[78483:7464849] 你向西
2017-06-30 17:19:50.126 RACDemo[78483:7464849] 他向东
2017-06-30 17:19:50.126 RACDemo[78483:7464849] 他向左
2017-06-30 17:19:50.127 RACDemo[78483:7464849] 你向右
6.信号转换
- map 转换信号值,返回新的信号;
- 代码示例:
- (void)testMap {
RACSignal *signal = [[RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
[subscriber sendNext:@"石"];
return nil;
}] map:^id(NSString* value) {
if ([value isEqualToString:@"石"]) {
return @"金";
}
return value;
}];
[signal subscribeNext:^(id x) {
NSLog(@"%@", x);
}];
}
输出结果为:
2017-06-29 10:35:41.914 RACDemo[69180:6961894] 金
- filter 过滤
- 代码示例:
- (void)testFilter {
[[[RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
[subscriber sendNext:@(15)];
[subscriber sendNext:@(17)];
[subscriber sendNext:@(21)];
[subscriber sendNext:@(14)];
[subscriber sendNext:@(30)];
return nil;
}] filter:^BOOL(NSNumber* value) {
return value.integerValue >= 18;
}] subscribeNext:^(id x) {
NSLog(@"%@", x);
}];
}
//过滤大于或者等于18的数字
输出结果为:
2017-06-29 10:39:13.718 RACDemo[69242:6964994] 21
2017-06-29 10:39:13.718 RACDemo[69242:6964994] 30
- ==flattenMap 直接转成新的信号
- 代码示例:
- (void)testFlattenMap {
[[[[RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
NSLog(@"打蛋液");
[subscriber sendNext:@"蛋液"];
[subscriber sendCompleted];
return nil;
}] flattenMap:^RACStream *(NSString* value) {
return [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
NSLog(@"把%@倒进锅里面煎",value);
[subscriber sendNext:@"煎蛋"];
[subscriber sendCompleted];
return nil;
}];
}] flattenMap:^RACStream *(NSString* value) {
return [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
NSLog(@"把%@装到盘里", value);
[subscriber sendNext:@"上菜"];
[subscriber sendCompleted];
return nil;
}];
}] subscribeNext:^(id x) {
NSLog(@"%@", x);
}];
}
输出结果为:
2017-06-29 11:02:05.035 RACDemo[69369:6975870] 打蛋液
2017-06-29 11:02:05.036 RACDemo[69369:6975870] 把蛋液倒进锅里面煎
2017-06-29 11:02:05.036 RACDemo[69369:6975870] 把煎蛋装到盘里
2017-06-29 11:02:05.036 RACDemo[69369:6975870] 上菜
- take 只取前几个订阅
- 代码示例：
- (void)testTake {
RACSubject *subject = [RACSubject subject];
//只取前两次的信号值
[[subject take:2] subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
[subject sendNext:@"1"];
[subject sendNext:@"2"];
[subject sendNext:@"3"];
[subject sendNext:@"4"];
}
输出结果为:
2017-06-29 11:41:22.418 RACDemo[69701:7001833] 1
2017-06-29 11:41:22.418 RACDemo[69701:7001833] 2
- takeLast 只取最后几个订阅
- 代码示例:
- (void)testTakeLast {
RACSubject *subject = [RACSubject subject];
//只取前两次的信号值
[[subject takeLast:2] subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
[subject sendNext:@"1"];
[subject sendNext:@"2"];
[subject sendNext:@"3"];
[subject sendNext:@"4"];
// 注意此处必须订阅完成 才能使用takeLast进行最后几次订阅的统计
[subject sendCompleted];
}
输出结果为:
2017-06-29 11:48:15.642 RACDemo[69834:7008684] 3
2017-06-29 11:48:15.642 RACDemo[69834:7008684] 4
- skip ：先跳过几个订阅
- 代码示例：
// 默认UITextField创建时就能订阅到其信号，往往会跳过第一次信号
[[self.textfield.rac_textSignal skip:1] subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
- ignore ：内部调用filter过滤,忽略掉ignore的值
- 代码示例:
- (void)testIgnore {
RACSubject *subject = [RACSubject subject];
//只取前两次的信号值
[[subject ignore:@"2"] subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
[subject sendNext:@"1"];
[subject sendNext:@"2"];
[subject sendNext:@"3"];
[subject sendNext:@"4"];
}输出结果为:
2017-06-29 12:06:56.999 RACDemo[69907:7018889] 1
2017-06-29 12:06:57.000 RACDemo[69907:7018889] 3
2017-06-29 12:06:57.000 RACDemo[69907:7018889] 4
- distinctUntilChanged ：只订阅当前信号值不同的信号
- 代码示例：
- (void)testDistinctUntilChanged {
RACSubject *subject = [RACSubject subject];
//当上一次的值和这次的值有明显变化的时候就会发出信号，否则会忽略掉
//一般用来刷新UI界面，当数据有变化的时候才会刷新
[[subject distinctUntilChanged] subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
[subject sendNext:@"A"];
[subject sendNext:@"A"];
[subject sendNext:@"B"];
}输出结果为:
2017-06-29 15:39:03.417 RACDemo[70120:7083874] A
2017-06-29 15:39:03.418 RACDemo[70120:7083874] B
- switchTolatest ：获取信号组中的信号
- 代码示例:
如上面RACCommand的代码栗子中:
// 监控请求成功的状态
[_command.executionSignals.switchToLatest subscribeNext:^(id x) {
NSLog(@"请求成功后，拿到数据: %@", x);
}];
这里的executionSignals返回的是信号组(本身也是信号类型), RACCommand每`excute:`一次就会向信号组中扔进去新的信号，这里我们先拿到信号组，然后用switchToLatest属性拿到这个最新的信号，最后再进行订阅。
7.信号拼接
- concat ：拼接.注意:在signalA后拼接signalB,只有signalA发送完 ==sendCompletd== ,signalB才会拼接
- 代码示例：
- (void)testConcat {
RACSignal *signalA = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
[subscriber sendNext:@"我恋爱啦"];
[subscriber sendCompleted];
return nil;
}];
RACSignal *signalB = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
[subscriber sendNext:@"我结婚啦"];
[subscriber sendCompleted];
return nil;
}];
[[signalA concat:signalB] subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
}
输出结果为:
2017-06-30 10:47:36.654 RACDemo[75454:7236811] 我恋爱啦
2017-06-30 10:47:36.655 RACDemo[75454:7236811] 我结婚啦
- then ：拼接.连接下一个信号,当信号完成后,才连接then后的信号
- 代码示例:
- (void)testThen {
// then:用于连接两个信号，当第一个信号完成，才会连接then返回的信号
// 注意使用then，之前信号的值会被忽略掉.
// 底层实现：1、先过滤掉之前的信号发出的值。2.使用concat连接then返回的信号
[[[RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
[subscriber sendNext:@1];
// 这里必须sendCompleted才能执行then后的信号
[subscriber sendCompleted];
return nil;
}] then:^RACSignal *{
return [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
[subscriber sendNext:@2];
return nil;
}];
}] subscribeNext:^(id x) {
// 只能接收到第二个信号的值，也就是then返回信号的值
NSLog(@"%@",x);
}];
}输出结果为:
2017-06-30 10:44:08.578 RACDemo[75394:7233518] 2
- merge ：合并.任何一个信号有新值的时候就会被订阅
- 代码示例:
- (void)testMerge {
RACSignal *signalA = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
[subscriber sendNext:@"纸厂污水"];
return nil;
}];
RACSignal *signalB = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
[subscriber sendNext:@"电镀厂污水"];
return nil;
}];
[[RACSignal merge:@[signalA, signalB]] subscribeNext:^(id x) {
NSLog(@"处理%@",x);
}];
}
输出结果为:
2017-06-30 10:55:58.645 RACDemo[75697:7244204] 处理纸厂污水
2017-06-30 10:55:58.645 RACDemo[75697:7244204] 处理电镀厂污水
```
- ==zip== (同步合并压缩)+ ==reduce== (分解元组)
- 代码示例:
```
- (void)testZip {
RACSubject *letters = [RACSubject subject];
RACSubject *numbers = [RACSubject subject];
RACSignal *zipSignal = [RACSignal zip:@[letters,numbers] reduce:^id(NSString *letter,NSString *number){
return [letter stringByAppendingString:number];
}];
[zipSignal subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
[letters sendNext:@"A"];
[letters sendNext:@"B"];
[numbers sendNext:@"1"];
[numbers sendNext:@"2"];
[numbers sendNext:@"3"];
[letters sendNext:@"C"];
[letters sendNext:@"D"];
[numbers sendNext:@"4"];
}
输出结果为:
2017-06-30 11:03:50.907 RACDemo[75837:7251093] A1
2017-06-30 11:03:50.908 RACDemo[75837:7251093] B2
2017-06-30 11:03:50.908 RACDemo[75837:7251093] C3
2017-06-30 11:03:50.908 RACDemo[75837:7251093] D4
/// zip后发出的信号值是元组类型，因此这里使用 reduce: 方法直接分解元素，拿到元组中对应的值
/// zip的合并行为是按顺序取出各个信号然后合并发出的
/// 也就是说,letters的第一个值A和number的第一个值1合并输出A1,第二个值B和number的第二个值2合并输出B2
/// 假设D后面,还有E,F,G...,但是没有对应的number信号,zip的合并行为就无法进行下去了.
- combineLatest (最新值合并压缩) + reduce (分解元组)
- 代码示例:
- (void)testCombineLatest{
RACSubject *letters = [RACSubject subject];
RACSubject *numbers = [RACSubject subject];
RACSignal *combined = [RACSignal combineLatest:@[letters,numbers] reduce:^id(NSString *letter,NSString *number){
return [letter stringByAppendingString:number];
}];
[combined subscribeNext:^(id x) {
NSLog(@"%@", x);
}];
[letters sendNext:@"A"];
[letters sendNext:@"B"];
[numbers sendNext:@"1"];
[numbers sendNext:@"2"];
[letters sendNext:@"C"];
[numbers sendNext:@"3"];
[letters sendNext:@"D"];
[numbers sendNext:@"4"];
}
输出结果为:
2017-06-30 11:12:59.470 RACDemo[75910:7256870] B1
2017-06-30 11:12:59.471 RACDemo[75910:7256870] B2
2017-06-30 11:12:59.471 RACDemo[75910:7256870] C2
2017-06-30 11:12:59.471 RACDemo[75910:7256870] C3
2017-06-30 11:12:59.471 RACDemo[75910:7256870] D3
2017-06-30 11:12:59.472 RACDemo[75910:7256870] D4/// combineLatest后发出的信号值是元组类型，因此这里使用 reduce: 方法直接分解元素，拿到元组中对应的值
/// 上面代码可以发现:letter信号的A值被更新的B值覆盖了,所以接下来接收到number信号的1时候,合并,输出信号B1.
/// 当接收到C的时候,与number的最新的值2合并,输出信号C2.
- takeUntil ：获取信号直接到某个信号开始执行
- 代码示例:
- (void)testTakeUntil {
[[[RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
[[RACSignal interval:1 onScheduler:[RACScheduler mainThreadScheduler]] subscribeNext:^(id x) {
[subscriber sendNext:@"直到世界的尽头才能把我们分开"];
}];
return nil;
}] takeUntil:[RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSLog(@"世界的尽头到了");
[subscriber sendNext:@"世界的尽头到了"];
});
return nil;
}]] subscribeNext:^(id x) {
NSLog(@"%@", x);
}];
}
输出结果为:
2017-06-30 11:46:55.103 RACDemo[75983:7272054] 直到世界的尽头才能把我们分开
2017-06-30 11:46:56.103 RACDemo[75983:7272054] 直到世界的尽头才能把我们分开
2017-06-30 11:46:57.103 RACDemo[75983:7272054] 直到世界的尽头才能把我们分开
2017-06-30 11:46:58.103 RACDemo[75983:7272054] 直到世界的尽头才能把我们分开
2017-06-30 11:46:59.102 RACDemo[75983:7272054] 世界的尽头到了
- doNext 、doCompleted 、doError 分别在 sendNext 、sendCopleted 和sendError 前执行操作
- 代码示例:
- (void)doNextOrComleted {
[[[[RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
[subscriber sendNext:@1];
[subscriber sendCompleted];
return nil;
}] doNext:^(id x) {
// 执行[subscriber sendNext:@1];之前会调用这个Block
NSLog(@"doNext");;
}] doCompleted:^{
// 执行[subscriber sendCompleted];之前会调用这个Block
NSLog(@"doCompleted");;
}] subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
}输出结果为:
2017-06-30 11:54:39.750 RACDemo[76163:7277651] doNext
2017-06-30 11:54:39.751 RACDemo[76163:7277651] 1
2017-06-30 11:54:39.751 RACDemo[76163:7277651] doCompleted
- rac_liftSelector ：每个信号至少sendNext一次后, 拿到每个信号最新的信号值,然后执行selector中的操作
- 代码示例:
- (void)testLiftSelector {
// 当多次数据请求时，需要全部请求结束之后才会进行下一步UI刷新等，可以用这个rac_liftSelector
// 第一部分数据
RACSignal *section01Signal01 = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
NSLog(@"section01数据请求");
[subscriber sendNext:@"section01请求到的数据"];
return nil;
}];
// 第二部分数据
RACSignal *section01Signal02 = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
NSLog(@"section02数据请求");
[subscriber sendNext:@"section02请求到的数据"];
return nil;
}];
// 第三部分数据
RACSignal *section01Signal03 = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
NSLog(@"section03数据请求");
[subscriber sendNext:@"section03请求到的数据"];
return nil;
}];
// 可以在所有信号请求完成之后再执行方法，只需把三个结果传出去即可
// 注意下面@selector中的参数数量和传递和信号数量是一致的
[self rac_liftSelector:@selector(refreshUI:::) withSignals:section01Signal01,section01Signal02,section01Signal03, nil];
}
- (void)refreshUI:(NSString *)str1 :(NSString *)str2 :(NSString *)str3 {
NSLog(@"最终数据为:\n%@\n%@\n%@", str1, str2, str3);
}输出结果为:
2017-06-30 12:07:43.382 RACDemo[76282:7286396] section01数据请求
2017-06-30 12:07:43.382 RACDemo[76282:7286396] section02数据请求
2017-06-30 12:07:43.382 RACDemo[76282:7286396] section03数据请求
2017-06-30 12:07:43.383 RACDemo[76282:7286396] 最终数据为:
section01请求到的数据
section02请求到的数据
section03请求到的数据
8.信号时间或频率控制
- timeOut 超时.超时一定时间后自动sendError
- 代码示例:
- (void)testTimeOut {
RACSignal *signal = [[RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
[subscriber sendNext:@"100"];
return nil;
}] timeout:1 onScheduler: [RACScheduler currentScheduler]]; // 这里将时间操作放在当前线程中执行
[signal subscribeNext:^(id x) {
NSLog(@"%@",x);
} error:^(NSError *error) {
NSLog(@"1秒后会自动调用");
}];
}输出结果为:
2017-06-30 12:20:41.715 RACDemo[76418:7295742] 100
2017-06-30 12:20:42.812 RACDemo[76418:7295742] 1秒后会自动调用
- delay ：延迟.延迟一定时间后在进行信息传递
- 代码示例:
- (void)testDelay {
[[[RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
NSLog(@"等等我，我还有3秒钟就到了");
[subscriber sendNext:nil];
[subscriber sendCompleted];
return nil;
}] delay:3] subscribeNext:^(id x) {
NSLog(@"我到了");
}];
}
输出结果为:
2017-06-30 12:27:15.584 RACDemo[76593:7301745] 等等我，我还有3秒钟就到了
2017-06-30 12:27:18.884 RACDemo[76593:7301745] 我到了
- replay 同RACReplaySubject实现原理一样,将要传递的值打包保存一次,然后依次派送给订阅者
- 代码示例:
- (void)testReplay {
RACSignal *signal = [[RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
[subscriber sendNext:@1];
[subscriber sendNext:@2];
return nil;
}] replay]; // 使用replay后上面block中的代码只执行一次
[signal subscribeNext:^(id x) {
NSLog(@"第一个订阅者%@",x);
}];
[signal subscribeNext:^(id x) {
NSLog(@"第二个订阅者%@",x);
}];
}输出结果为:
2017-06-30 14:39:10.989 RACDemo[76768:7350292] 第一个订阅者1
2017-06-30 14:39:11.778 RACDemo[76768:7350292] 第一个订阅者2
2017-06-30 14:39:12.394 RACDemo[76768:7350292] 第二个订阅者1
2017-06-30 14:39:13.068 RACDemo[76768:7350292] 第二个订阅者2
- retry 错误重试,订阅者sendError后重新执行信号block操作
- 代码示例:
- (void)testRetry {
__block int failedCount = 0;
[[[RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
if (failedCount < 5) {
failedCount++;
NSLog(@"我失败了");
[subscriber sendError:nil];
}else{
NSLog(@"经历了五次失败后");
[subscriber sendNext:nil];
}
return nil;
}] retry] subscribeNext:^(id x) {
NSLog(@"终于成功了");
}];
}
输出结果为:
2017-06-30 14:47:19.473 RACDemo[76899:7358317] 我失败了
2017-06-30 14:47:19.474 RACDemo[76899:7358317] 我失败了
2017-06-30 14:47:19.475 RACDemo[76899:7358317] 我失败了
2017-06-30 14:47:19.475 RACDemo[76899:7358317] 我失败了
2017-06-30 14:47:19.475 RACDemo[76899:7358317] 我失败了
2017-06-30 14:47:19.475 RACDemo[76899:7358317] 经历了五次失败后
2017-06-30 14:47:19.475 RACDemo[76899:7358317] 终于成功了
另外:
- (RACSignal *)retry:(NSInteger)retryCount; 方法可以控制重试的次数。
- interval 定时,每隔一段时间激活一次信号
- 代码示例:
- (void)testInterval {
__block int num = 0;
[[[RACSignal interval:1 onScheduler:[RACScheduler mainThreadScheduler]] takeUntil:self.rac_willDeallocSignal] subscribeNext:^(id x) {
num++;
NSLog(@"count：%d", num);
}];
}输出结果为:
2017-06-30 14:57:02.553 RACDemo[77081:7365782] count：1
2017-06-30 14:57:03.553 RACDemo[77081:7365782] count：2
2017-06-30 14:57:04.553 RACDemo[77081:7365782] count：3
2017-06-30 14:57:05.553 RACDemo[77081:7365782] count：4
2017-06-30 14:57:06.553 RACDemo[77081:7365782] count：5
···
- throttle 节流.一定时间内不接收任何信号内容,一旦到达这个时间就获取最新最近的信号内容
- 代码示例:
- (void)testThrottle {
[[[RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
[subscriber sendNext:@"旅客A"];
// 1秒时发送一条信息
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
[subscriber sendNext:@"旅客B"];
});
// 1.5秒时发送一条信息
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1.5 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
[subscriber sendNext:@"插队旅客"];
});
// 2秒时发送三条信息
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
[subscriber sendNext:@"旅客C"];
[subscriber sendNext:@"旅客D"];
[subscriber sendNext:@"旅客E"];
});
// 3秒时发送一条信息
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
[subscriber sendNext:@"旅客F"];
});
return nil;
}] throttle:1] subscribeNext:^(id x) {
NSLog(@"%@通过了",x);
}];
}
输出结果为:
2017-06-30 15:10:44.948 RACDemo[77224:7375779] 旅客A通过了
2017-06-30 15:10:46.947 RACDemo[77224:7375779] 旅客E通过了
2017-06-30 15:10:48.046 RACDemo[77224:7375779] 旅客F通过了
扫一扫
163
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
