Reactive|Reactive Cocoa 学习笔记
Reactive Cocoa 学习笔记
[TOC]
基本概念
什么是RAC
ReacticeCocoa 结合了好几种编码风格：
- 函数式编程——利用高阶函数，即函数将其它函数作为其参数
- 反应性编程——注重于数据流和改变传播
RAC具有函数式编程和响应式编程的特性。为什么要学习
为了提高我们的开发效率。RAC在某些特定情况下开发时可以大大简化代码，并且目前来看安全可靠。
常用场景 事件监听
// 监听了textFild的UIControlEventEditingChanged事件，当事件发生时实现方法NSLog
[[self.textFild rac_signalForControlEvents:UIControlEventEditingChanged] subscribeNext:^(id x){
NSLog(@"change");
}];
// 对于UITextField更简单的写法
[[self.textFild rac_textSignal] subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
// 再比如给我们的某个label添加一个手势动作
UITapGestureRecognizer *tap = [[UITapGestureRecognizer alloc] init];
[[tap rac_gestureSignal] subscribeNext:^(id x) {
NSLog(@"tap");
}];
[self.view addGestureRecognizer:tap];
代理
用RAC写代理是有局限的，它只能实现返回值为void的代理方法首先我们要明白我们为什么要用RAC写代理？答：简化代码！
是的，的确为了简化代码，为什么我要再这里强调这个，是因为在代理方法中我深深的感受到了RAC的优点。一开始我也不愿意花功夫去学RAC，但是我师父给我举了一个例子，，然后再往代理点击事件里加各种方法，代码就又臭又长。那么让我们看看RAC怎么写代理方法。
// 如果一个View里有多个AlertView，每个AlertView有很多个按钮，每个按钮都有自己的点击事件，不但每个按钮需要打标记，而且每个AlertView也要打标记
UIAlertView *alertView = [[UIAlertView alloc] initWithTitle:@"RAC" message:@"RAC TEST" delegate:self cancelButtonTitle:@"cancel" otherButtonTitles:@"other", nil];
[[self rac_signalForSelector:@selector(alertView:clickedButtonAtIndex:) fromProtocol:@protocol(UIAlertViewDelegate)] subscribeNext:^(RACTuple *tuple) {
//tuple 保存delegate方法中的各个参数
NSLog(@"%@",tuple.first);
NSLog(@"%@",tuple.second);
NSLog(@"%@",tuple.third);
}];
[alertView show];
-------------------
2016-01-04 18:24:29.114 RACStudyTest[5003:388870] >
2016-01-04 18:24:29.115 RACStudyTest[5003:388870] 1
2016-01-04 18:24:29.115 RACStudyTest[5003:388870] (null)
--------------// 简化写法
[[alertView rac_buttonClickedSignal] subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
通知
这句话是不对的‘RAC中的通知不需要remove observer，因为在rac_add方法中他已经写了remove。’
// 发送通知
NSMutableArray *dataArray = [[NSMutableArray alloc] initWithObjects:@"1", @"2", @"3", nil];
[[NSNotificationCenter defaultCenter] postNotificationName:@"postData" object:dataArray];
// 接收通知
[[[[NSNotificationCenter defaultCenter]
rac_addObserverForName:@"postData" object:nil]
takeUntil:self.rac_willDeallocSignal]
subscribeNext:^(NSNotification *notification) {
NSLog(@"%@", notification.name);
NSLog(@"%@", notification.object);
}];
------------------------------------------------------------------------
2016-01-04 20:10:52.274 RACStudyTest[5918:439077] postData
2016-01-04 20:10:52.275 RACStudyTest[5918:439077] (
1,
2,
3
)
-----------------------------------------------------------------------
为什么这里要执行takeUntil？？因为，[[NSNotificationCenter defaultCenter] rac_addObserverForName:UIKeyboardWillHideNotification object:nil]本来是冷信号，订阅以后立即变成热信号。如果不做这一步操作，self即使释放了，订阅的block也是不会释放的。每次通知发出的时候，还是会再次来到这个block去处理。
KVO
RAC中得KVO大部分都是宏定义，所以代码异常简洁，简单来说就是RACObserve(TARGET, KEYPATH)这种形式，TARGET是监听目标，KEYPATH是要观察的属性值。
UIScrollView *scrolView = [[UIScrollView alloc] initWithFrame:CGRectMake(0, 0, 200, 400)];
scrolView.contentSize = CGSizeMake(200, 800);
scrolView.backgroundColor = [UIColor greenColor];
[self.view addSubview:scrolView];
[RACObserve(scrolView, contentOffset) subscribeNext:^(id x) {
NSLog(@"success");
}];
// RAC:把一个对象的某个属性绑定一个信号,只要发出信号,就会把信号的内容给对象的属性赋值
// 给label的text属性绑定了文本框改变的信号
RAC(self.label, text) = self.textField.rac_textSignal;
//[self.textField.rac_textSignal subscribeNext:^(id x) {
//self.label.text = x;
//}];
核心概念 RACSignal
信号可以看做是传递信号的工具，当数据变化时，信号就会发送改变的信息，以通知信号的订阅者执行方法。热/冷信号
默认一个信号都是冷信号，也就是值改变了，也不会触发，只有订阅了这个信号，这个信号才会变为热信号，值改变了才会触发。
RACSubject是一个有趣的信号类型。在'ReactiveCocoa'的世界中，她是一个可变的状态。她是一个你可以主动发送新值的信号。出于这个原因，除非情况特殊，我们不推荐使用她。
//创建信号
RACSignal *signal = [RACSignal createSignal:^RACDisposable *(id subscriber) {
[subscriber sendNext:@"signal"];
[subscriber sendCompleted];
return nil;
}];
//订阅信号
[signal subscribeNext:^(id x) {
NSLog(@"x = %@", x);
} error:^(NSError *error) {
NSLog(@"error = %@", error);
} completed:^{
NSLog(@"completed");
}];
——————————————
2016-01-05 14:33:06.106 RACStudyTest[895:38671] x = signal
2016-01-05 14:33:06.106 RACStudyTest[895:38671] completed
——————————————
RACCommand
- RACCommand:RAC中用于处理事件的类，可以把事件如何处理，事件中的数据如何传递，包装到这个类中，他可以很方便的监控事件的执行过程，比如看事件有没有执行完毕
- 使用场景：监听按钮点击，网络请求
// 普通做法
// RACCommand: 处理事件
// 不能返回空的信号
// 1.创建命令
RACCommand *command = [[RACCommand alloc] initWithSignalBlock:^RACSignal *(id input) {
//block调用，执行命令的时候就会调用
NSLog(@"%@",input);
// input 为执行命令传进来的参数
// 这里的返回值不允许为nil
return [RACSignal createSignal:^RACDisposable *(id subscriber) {
[subscriber sendNext:@"执行命令产生的数据"];
return nil;
}];
}];
// 如何拿到执行命令中产生的数据呢？
// 订阅命令内部的信号
// ** 方式一：直接订阅执行命令返回的信号// 2.执行命令
RACSignal *signal =[command execute:@2];
// 这里其实用到的是replaySubject 可以先发送命令再订阅
// 在这里就可以订阅信号了
[signal subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
// 一般做法
// 1.创建命令
RACCommand *command = [[RACCommand alloc] initWithSignalBlock:^RACSignal *(id input) {
//block调用，执行命令的时候就会调用
NSLog(@"%@",input);
// input 为执行命令传进来的参数
// 这里的返回值不允许为nil
return [RACSignal createSignal:^RACDisposable *(id subscriber) {
[subscriber sendNext:@"执行命令产生的数据"];
return nil;
}];
}];
// 方式二：
// 订阅信号
// 注意：这里必须是先订阅才能发送命令
// executionSignals：信号源，信号中信号，signalofsignals:信号，发送数据就是信号
[command.executionSignals subscribeNext:^(RACSignal *x) {
[x subscribeNext:^(id x) {
NSLog(@"%@", x);
}];
//NSLog(@"%@", x);
}];
// 2.执行命令
[command execute:@2];
// 高级做法
// 1.创建命令
RACCommand *command = [[RACCommand alloc] initWithSignalBlock:^RACSignal *(id input) {
// block调用：执行命令的时候就会调用
NSLog(@"%@", input);
// 这里的返回值不允许为nil
return [RACSignal createSignal:^RACDisposable *(id subscriber) {
[subscriber sendNext:@"发送信号"];
return nil;
}];
}];
// 方式三
// switchToLatest获取最新发送的信号，只能用于信号中信号。
[command.executionSignals.switchToLatest subscribeNext:^(id x) {
NSLog(@"%@", x);
}];
// 2.执行命令
[command execute:@3];
// switchToLatest--用于信号中信号
// 创建信号中信号
RACSubject *signalofsignals = [RACSubject subject];
RACSubject *signalA = [RACSubject subject];
// 订阅信号
//[signalofsignals subscribeNext:^(RACSignal *x) {
//[x subscribeNext:^(id x) {
//NSLog(@"%@", x);
//}];
//}];
// switchToLatest: 获取信号中信号发送的最新信号
[signalofsignals.switchToLatest subscribeNext:^(id x) {
NSLog(@"%@", x);
}];
// 发送信号
[signalofsignals sendNext:signalA];
[signalA sendNext:@4];
// 监听事件有没有完成
//注意：当前命令内部发送数据完成，一定要主动发送完成
// 1.创建命令
RACCommand *command = [[RACCommand alloc] initWithSignalBlock:^RACSignal *(id input) {
// block调用：执行命令的时候就会调用
NSLog(@"%@", input);
// 这里的返回值不允许为nil
return [RACSignal createSignal:^RACDisposable *(id subscriber) {
// 发送数据
[subscriber sendNext:@"执行命令产生的数据"];
// *** 发送完成 **
[subscriber sendCompleted];
return nil;
}];
}];
// 监听事件有没有完成
[command.executing subscribeNext:^(id x) {
if ([x boolValue] == YES) { // 正在执行
NSLog(@"当前正在执行%@", x);
}else {
// 执行完成/没有执行
NSLog(@"执行完成/没有执行");
}
}];
// 2.执行命令
[command execute:@1];
RACMulticastConnection
当有多个订阅者，但是我们只想发送一个信号的时候怎么办？这时我们就可以用RACMulticastConnection，来实现。代码示例如下
// 普通写法, 这样的缺点是：没订阅一次信号就得重新创建并发送请求，这样很不友好
RACSignal *signal = [RACSignal createSignal:^RACDisposable *(id subscriber) {
// didSubscribeblock中的代码都统称为副作用。
// 发送请求---比如afn
NSLog(@"发送请求啦");
// 发送信号
[subscriber sendNext:@"ws"];
return nil;
}];
[signal subscribeNext:^(id x) {
NSLog(@"%@", x);
}];
[signal subscribeNext:^(id x) {
NSLog(@"%@", x);
}];
[signal subscribeNext:^(id x) {
NSLog(@"%@", x);
}];
// 比较好的做法。 使用RACMulticastConnection，无论有多少个订阅者，无论订阅多少次，我只发送一个。
// 1.发送请求，用一个信号内包装，不管有多少个订阅者，只想发一次请求
RACSignal *signal = [RACSignal createSignal:^RACDisposable *(id subscriber) {
// 发送请求
NSLog(@"发送请求啦");
// 发送信号
[subscriber sendNext:@"ws"];
return nil;
}];
//2. 创建连接类
RACMulticastConnection *connection = [signal publish];
[connection.signal subscribeNext:^(id x) {
NSLog(@"%@", x);
}];
[connection.signal subscribeNext:^(id x) {
NSLog(@"%@", x);
}];
[connection.signal subscribeNext:^(id x) {
NSLog(@"%@", x);
}];
//3. 连接。只有连接了才会把信号源变为热信号
[connection connect];
RACSequence
使用场景---： 可以快速高效的遍历数组和字典。
NSString *path = [[NSBundle mainBundle] pathForResource:@"flags.plist" ofType:nil];
NSArray *dictArr = [NSArray arrayWithContentsOfFile:path];
[dictArr.rac_sequence.signal subscribeNext:^(id x) {
NSLog(@"%@", x);
} error:^(NSError *error) {
NSLog(@"===error===");
} completed:^{
NSLog(@"ok---完毕");
}];
也可以使用宏NSDictionary *dict = @{@"key":@1, @"key2":@2};
[dict.rac_sequence.signal subscribeNext:^(id x) {
NSLog(@"%@", x);
NSString *key = x[0];
NSString *value = https://www.it610.com/article/x[1];
// RACTupleUnpack宏：专门用来解析元组
// RACTupleUnpack 等会右边：需要解析的元组 宏的参数，填解析的什么样数据
// 元组里面有几个值，宏的参数就必须填几个
RACTupleUnpack(NSString *key, NSString *value) = x;
NSLog(@"%@ %@", key, value);
} error:^(NSError *error) {
NSLog(@"===error");
} completed:^{
NSLog(@"-----ok---完毕");
}];
信号的处理
信号映射 map
[[self.textField.rac_textSignal map:^id(id value) {
NSLog(@"in map block :%@", value);
return @1;
}] subscribeNext:^(id x) {
NSLog(@"in subscribe block :%@", x);
}];
//在textField中输入Goods 打印结果如下
_________________
(function:__33-[QYKVCKVOViewController setupUI]_block_invoke):in map block :
(function:__33-[QYKVCKVOViewController setupUI]_block_invoke_2):in subscribe block :1
(function:__33-[QYKVCKVOViewController setupUI]_block_invoke):in map block :G
(function:__33-[QYKVCKVOViewController setupUI]_block_invoke_2):in subscribe block :1
(function:__33-[QYKVCKVOViewController setupUI]_block_invoke):in map block :Go
(function:__33-[QYKVCKVOViewController setupUI]_block_invoke_2):in subscribe block :1
(function:__33-[QYKVCKVOViewController setupUI]_block_invoke):in map block :Goo
(function:__33-[QYKVCKVOViewController setupUI]_block_invoke_2):in subscribe block :1
(function:__33-[QYKVCKVOViewController setupUI]_block_invoke):in map block :Good
(function:__33-[QYKVCKVOViewController setupUI]_block_invoke_2):in subscribe block :1
flatmap
// 创建信号
RACSubject *subject = [RACSubject subject];
// 绑定信号
RACSignal *bindSignal = [subject flattenMap:^RACStream *(id value) {
// block：只要源信号发送内容就会调用
// value: 就是源信号发送的内容
// 返回信号用来包装成修改内容的值
return [RACReturnSignal return:value];
}];
// flattenMap中返回的是什么信号，订阅的就是什么信号(那么，x的值等于value的值，如果我们操纵value的值那么x也会随之而变)
// 订阅信号
[bindSignal subscribeNext:^(id x) {
NSLog(@"%@", x);
}];
// 发送数据
[subject sendNext:@"123"];
}
// flattenMap 主要用于信号中的信号
// 创建信号
RACSubject *signalofSignals = [RACSubject subject];
RACSubject *signal = [RACSubject subject];
// 订阅信号
//方式1
//[signalofSignals subscribeNext:^(id x) {
//
//[x subscribeNext:^(id x) {
//NSLog(@"%@", x);
//}];
//}];
// 方式2
//[signalofSignals.switchToLatest];
// 方式3
//RACSignal *bignSignal = [signalofSignals flattenMap:^RACStream *(id value) {
//
////value:就是源信号发送内容
//return value;
//}];
//[bignSignal subscribeNext:^(id x) {
//NSLog(@"%@", x);
//}];
// 方式4--------也是开发中常用的
[[signalofSignals flattenMap:^RACStream *(id value) {
return value;
}] subscribeNext:^(id x) {
NSLog(@"%@", x);
}];
// 发送信号
[signalofSignals sendNext:signal];
[signal sendNext:@"123"];
信号过滤 filter
[[self.textFild.rac_textSignal filter:^BOOL(NSString *value) {
return [value length] > 3;
}] subscribeNext:^(id x) {
NSLog(@"x = %@", x);
}];
// 输入goodnight，输出：
——————————————
2016-01-05 15:18:20.492 RACStudyTest[1490:66721] x = good
2016-01-05 15:18:27.917 RACStudyTest[1490:66721] x = goodn
2016-01-05 15:18:28.129 RACStudyTest[1490:66721] x = goodni
2016-01-05 15:18:28.433 RACStudyTest[1490:66721] x = goodnig
2016-01-05 15:18:28.930 RACStudyTest[1490:66721] x = goodnigh
2016-01-05 15:18:29.155 RACStudyTest[1490:66721] x = goodnighttake/skip/repeat take是获取，skip是跳过，这两个方法后面跟着的都是NSInteger。
所以
take 2就是获取前两个信号，skip 2就是跳过前两个。repeat是重复发送信号。
相似的还有
takeLast、takeUntil、 takeWhileBlock、 skipWhileBlock、 skipUntilBlock、 repeatWhileBlock都可以根据字面意思来理解。// 这个demo只会输出前两个信号1和2还有完成信号completed，skip,repeat同理。
RACSignal *signal = [[RACSignal createSignal:^RACDisposable *(id subscriber) {
[subscriber sendNext:@"1"];
[subscriber sendNext:@"2"];
[subscriber sendNext:@"3"];
[subscriber sendNext:@"4"];
[subscriber sendNext:@"5"];
[subscriber sendCompleted];
return nil;
}] take:2];
[signal subscribeNext:^(id x) {
NSLog(@"%@", x);
}completed:^{
NSLog(@"completed");
}];
// takeUntil:---给takeUntil传的是哪个信号，那么当这个信号发送信号或sendCompleted，就不能再接受源信号的内容了。
RACSubject *subject = [RACSubject subject];
RACSubject *subject2 = [RACSubject subject];
[[subject takeUntil:subject2] subscribeNext:^(id x) {
NSLog(@"%@", x);
}];
// 发送信号
[subject sendNext:@1];
[subject sendNext:@2];
[subject2 sendNext:@3];
// 1
//[subject2 sendCompleted];
// 或2
[subject sendNext:@4];
throttle 节流，在我们做搜索框的时候，有时候需求的时实时搜索，即用户每每输入字符，view都要求展现搜索结果。这时如果用户搜索的字符串较长，那么由于网络请求的延时可能造成UI显示错误，并且多次不必要的请求还会加大服务器的压力，这显然是不合理的，此时我们就需要用到节流。
[[[self.textFild rac_textSignal] throttle:0.5] subscribeNext:^(id x) {
NSLog(@"%@", x);
}];
加了节流管道，后面跟上了类型为NSTimeInterval的参数后，只有0.5S内信号不产生变化才会发送请求，这样快速的输入也不会造成多次输出。
distinctUntilChanged 网络请求中为了减轻服务器压力，无用的请求我们应该尽可能不发送。distinctUntilChanged的作用是使RAC不会连续发送两次相同的信号，这样就解决了这个问题。
[[[self.textFild rac_textSignal] distinctUntilChanged] subscribeNext:^(id x) {
NSLog(@"%@", x);
}];
ignore 忽略信号，指定一个任意类型的量（可以是字符串，数组等），当需要发送信号时讲进行判断，若相同则该信号会被忽略发送。
[[[self.textFild rac_textSignal] ignore:@"good"] subscribeNext:^(id x) {
NSLog(@"%@", x);
}];
信号组合 combineLatest:reduce 使用一个 signals 信号的数组;
在任意signal变化时,使用他们的最后一次的值来执行block;
并返回一个新的 RACSignal信号对象来将block的值用作属性的新值来发送;
简单说,类似于重写createEnabled 属性的 getter 方法.
// 思路--- 就是把输入框输入值的信号都聚合成按钮是否能点击的信号。
// combineLatest 将两个信号聚合成一个信号
RACSignal *combinSignal = [RACSignal combineLatest:@[self.accountField.rac_textSignal, self.pwdField.rac_textSignal]
reduce:^id(NSString *account, NSString *pwd){ //reduce里的参数一定要和combineLatest数组里的一一对应。
// block: 只要源信号发送内容，就会调用，组合成一个新值。
NSLog(@"%@ %@", account, pwd);
return @(account.length && pwd.length);
}];
//// 订阅信号
//[combinSignal subscribeNext:^(id x) {
//self.loginBtn.enabled = [x boolValue];
//}];
// ----这样写有些麻烦，可以直接用RAC宏
RAC(self.loginBtn, enabled) = combinSignal;
zipWith zipWith:把两个信号压缩成一个信号，只有当两个信号同时发出信号内容时，并且把两个信号的内容合并成一个元祖，才会触发压缩流的next事件。
// 创建信号A
RACSubject *signalA = [RACSubject subject];
// 创建信号B
RACSubject *signalB = [RACSubject subject];
// 压缩成一个信号
// **-zipWith-**: 当一个界面多个请求的时候，要等所有请求完成才更新UI
// 等所有信号都发送内容的时候才会调用
RACSignal *zipSignal = [signalA zipWith:signalB];
[zipSignal subscribeNext:^(id x) {
NSLog(@"%@", x);
//所有的值都被包装成了元组
}];
// 发送信号 交互顺序，元组内元素的顺序不会变，跟发送的顺序无关，而是跟压缩的顺序有关[signalA zipWith:signalB]---先是A后是B
[signalA sendNext:@1];
[signalB sendNext:@2];
merge merge:多个信号合并成一个信号，任何一个信号有新值就会调用
// 任何一个信号请求完成都会被订阅到
// 创建信号A
RACSubject *signalA = [RACSubject subject];
// 创建信号B
RACSubject *signalB = [RACSubject subject];
//组合信号
RACSignal *mergeSignal = [signalA merge:signalB];
// 订阅信号
[mergeSignal subscribeNext:^(id x) {
NSLog(@"%@", x);
}];
// 发送信号---交换位置则数据结果顺序也会交换
[signalB sendNext:@"下部分"];
[signalA sendNext:@"上部分"];
}
then
// 创建信号A
RACSignal *signalA = [RACSignal createSignal:^RACDisposable *(id subscriber) {
// 发送请求
NSLog(@"----发送上部分请求---afn");
[subscriber sendNext:@"上部分数据"];
[subscriber sendCompleted];
// 必须要调用sendCompleted方法！
return nil;
}];
// 创建信号B，
RACSignal *signalsB = [RACSignal createSignal:^RACDisposable *(id subscriber) {
// 发送请求
NSLog(@"--发送下部分请求--afn");
[subscriber sendNext:@"下部分数据"];
return nil;
}];
// 创建组合信号
// then;
忽略掉第一个信号的所有值
RACSignal *thenSignal = [signalA then:^RACSignal *{
// 返回的信号就是要组合的信号
return signalsB;
}];
// 订阅信号
[thenSignal subscribeNext:^(id x) {
NSLog(@"%@", x);
}];
concat // concat----- 使用需求：有两部分数据：想让上部分先执行，完了之后再让下部分执行（都可获取值）
// 创建信号A
RACSignal *signalA = [RACSignal createSignal:^RACDisposable *(id subscriber) {
// 发送请求
//NSLog(@"----发送上部分请求---afn");
[subscriber sendNext:@"上部分数据"];
[subscriber sendCompleted];
// 必须要调用sendCompleted方法！
return nil;
}];
// 创建信号B，
RACSignal *signalsB = [RACSignal createSignal:^RACDisposable *(id subscriber) {
// 发送请求
//NSLog(@"--发送下部分请求--afn");
[subscriber sendNext:@"下部分数据"];
return nil;
}];
// concat:按顺序去链接
//**-注意-**：concat，第一个信号必须要调用sendCompleted
// 创建组合信号
RACSignal *concatSignal = [signalA concat:signalsB];
// 订阅组合信号
[concatSignal subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
其他操作 delay 延时信号，顾名思义，即延迟发送信号。
RACSignal *signal = [[RACSignal createSignal:^RACDisposable *(id subscriber) {
[subscriber sendNext:@"delay"];
[subscriber sendCompleted];
return nil;
}] delay:2];
NSLog(@"tag");
[signal subscribeNext:^(id x) {
NSLog(@"%@", x);
}];
_________________
2016-01-05 15:27:55.908 RACStudyTest[1543:71256] tag
2016-01-05 15:27:58.102 RACStudyTest[1543:71256] delay
//还有0.2s误差是因为运行到不同代码行的时间差
timeout 超时信号，当超出限定时间后会给订阅者发送error信号。
RACSignal *signal = [[RACSignal createSignal:^RACDisposable *(id subscriber) {
[[RACScheduler mainThreadScheduler] afterDelay:3 schedule:^{
[subscriber sendNext:@"delay"];
[subscriber sendCompleted];
}];
return nil;
}] timeout:2 onScheduler:[RACScheduler mainThreadScheduler]];
[signal subscribeNext:^(id x) {
NSLog(@"%@", x);
} error:^(NSError *error) {
NSLog(@"%@", error);
}];
//由于在创建信号是限定了延迟3秒发送，但是加了timeout2秒的限定，所以这一定是一个超时信号。这个信号被订阅后，由于超时，不会执行订阅成功的输出x方法，而是跳到error的块输出了错误信息。timeout在用RAC封装网络请求时可以节省不少的代码量。
_________________
2016-01-05 15:41:58.686 RACStudyTest[1604:76716] Error Domain=RACSignalErrorDomain Code=1 "The operation couldn’t be completed. (RACSignalErrorDomain error 1.)" 点评场景 whiteBoard
//TODO
- (void)setupModule
{
[self setupTitleCell];
[self setupPickDateCell];
@weakify(self)
[NVWBObserve(self, product) subscribeNext:^(NVModelBaseZeusProduct *product)
{
@strongify(self);
self.packageList = product.zeusSpuPackageList;
}];
}
网络请求
- (void)queryZeusDetailInfo
{
mparam_zeusproductdetail_travel *params = [mparam_zeusproductdetail_travel new];
params.spuid = @(_spuid);
params.cityid = @([NVLocateHelper sharedInstance].city.uid);
@weakify(self);
[[[NVNetworkClient client] mapi_zeusproductdetail_travel_withParameters:params cachePolicy:NVCacheTypeDisabled] subscribeNext:^(NVModelBaseZeusProductDetail *productDetail) {
@strongify(self);
self.productDetail = productDetail;
[self needReloadTableView];
} error:^(NSError *error) {
}];
}
高级进阶 热/冷信号
//TODO
实现原理 【Reactive|Reactive Cocoa 学习笔记】//TODO
参考链接
- ReactiveCocoa github主页
- RACSignal的基本用法
- RACSignal的Subscription深入分析
- 细说ReactiveCocoa的冷信号与热信号（一）
- 细说ReactiveCocoa的冷信号与热信号（二）
- iOS的函数响应型编程
推荐阅读
- 由浅入深理解AOP
- 继续努力，自主学习家庭Day135(20181015）
- python学习之|python学习之 实现QQ自动发送消息
- 一起来学习C语言的字符串转换函数
- 定制一套英文学习方案
- 漫画初学者如何学习漫画背景的透视画法（这篇教程请收藏好了！）
- 《深度倾听》第5天──「RIA学习力」便签输出第16期
- 如何更好的去学习
- 【韩语学习】（韩语随堂笔记整理）
- 焦点学习田源分享第267天《来访》