RAC使用测试Demo下载：github.com/FuWees/WPRACTestDemo
1.ReactiveCocoa简介
ReactiveCocoa（简称为RAC）,是由Github开源的一个应用于iOS和OS开发的新框架,Cocoa是苹果整套框架的简称，因此很多苹果框架喜欢以Cocoa结尾。
2.ReactiveCocoa作用
ReactiveCocoa为事件提供了很多处理方法，而且利用RAC处理事件很方便，可以把要处理的事情，和监听的事情的代码放在一起，这样非常方便我们管理，就不需要跳到对应的方法里。非常符合我们开发中高聚合，低耦合的思想。
3.ReactiveCocoa编程思想
ReactiveCocoa结合了几种编程风格：
函数式编程（Functional
Programming）：是把操作尽量写成一系列嵌套的函数或者方法调用。
函数式编程特点：每个方法必须有返回值（本身对象）,把函数或者Block当做参数,block参数（需要操作的值）block返回值（操作结果）
响应式编程（Reactive
Programming）：不需要考虑调用顺序，只需要知道考虑结果，类似于蝴蝶效应，产生一个事件，会影响很多东西，这些事件像流一样的传播出去，然后影响结果，借用面向对象的一句话，万物皆是流。
代表：KVO运用
所以，你可能听说过ReactiveCocoa被描述为函数响应式编程（FRP）框架。
以后使用RAC解决问题，就不需要考虑调用顺序，直接考虑结果，把每一次操作都写成一系列嵌套的方法中，使代码高聚合，方便管理。
4.ReactiveCocoa常见类。
4.1RACSiganl:信号类,一般表示将来有数据传递，只要有数据改变，信号内部接收到数据，就会马上发出数据。
注意：
•信号类(RACSiganl)，只是表示当数据改变时，信号内部会发出数据，它本身不具备发送信号的能力，而是交给内部一个订阅者去发出。
•默认一个信号都是冷信号，也就是值改变了，也不会触发，只有订阅了这个信号，这个信号才会变为热信号，值改变了才会触发。
如何订阅信号：调用信号RACSignal的subscribeNext就能订阅。
//
RACSignal使用步骤：
//1.创建信号+ (RACSignal *)createSignal:(RACDisposable
* (^)(id subscriber))didSubscribe
//2.订阅信号,才会激活信号.
- (RACDisposable *)subscribeNext:(void (^)(id x))nextBlock
//3.发送信号- (void)sendNext:(id)value
// RACSignal底层实现：
// 1.创建信号，首先把didSubscribe保存到信号中，还不会触发。
// 2.当信号被订阅，也就是调用signal的subscribeNext:nextBlock
// 2.2
subscribeNext内部会创建订阅者subscriber，并且把nextBlock保存到subscriber中。
// 2.1
subscribeNext内部会调用siganl的didSubscribe
// 3.siganl的didSubscribe中调用[subscriber sendNext:@1];
// 3.1 sendNext底层其实就是执行subscriber的nextBlock
// 1.创建信号
RACSignal *siganl = [RACSignal createSignal:^RACDisposable*(id subscriber) {
// block调用时刻：每当有订阅者订阅信号，就会调用block。
// 2.发送信号
[subscriber sendNext:@1];
//如果不在发送数据，最好发送信号完成，内部会自动调用[RACDisposable disposable]取消订阅信号。
[subscriber sendCompleted];
return [RACDisposabledisposableWithBlock:^{
// block调用时刻：当信号发送完成或者发送错误，就会自动执行这个block,取消订阅信号。
//执行完Block后，当前信号就不在被订阅了。
NSLog(@"信号被销毁");
}];
}];
// 3.订阅信号,才会激活信号.
[siganl subscribeNext:^(id x) {
// block调用时刻：每当有信号发出数据，就会调用block.
NSLog(@"接收到数据:%@",x);
}];
4.2RACSubscriber:表示订阅者的意思，用于发送信号，这是一个协议，不是一个类，只要遵守这个协议，并且实现方法才能成为订阅者。通过create创建的信号，都有一个订阅者，帮助他发送数据。
4.3RACDisposable:用于取消订阅或者清理资源，当信号发送完成或者发送错误的时候，就会自动触发它。
使用场景:不想监听某个信号时，可以通过它主动取消订阅信号。
4.4RACSubject:信号提供者，自己可以充当信号，又能发送信号。
•使用场景:通常用来代替代理，有了它，就不必要定义代理了。
RACReplaySubject:重复提供信号类，RACSubject的子类。
•RACReplaySubject与RACSubject区别:
RACReplaySubject可以先发送信号，在订阅信号，RACSubject就不可以。
•使用场景一:如果一个信号每被订阅一次，就需要把之前的值重复发送一遍，使用重复提供信号类。
•使用场景二:可以设置capacity数量来限制缓存的value的数量,即只缓充最新的几个值。
•RACSubject和RACReplaySubject简单使用:
// 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:@"1"];
//
RACReplaySubject使用步骤:
// 1.创建信号[RACSubject subject]，跟RACSiganl不一样，创建信号时没有block。
// 2.可以先订阅信号，也可以先发送信号。
// 2.1订阅信号- (RACDisposable *)subscribeNext:(void (^)(id x))nextBlock
// 2.2发送信号sendNext:(id)value
//
RACReplaySubject:底层实现和RACSubject不一样。
// 1.调用sendNext发送信号，把值保存起来，然后遍历刚刚保存的所有订阅者，一个一个调用订阅者的nextBlock。
// 2.调用subscribeNext订阅信号，遍历保存的所有值，一个一个调用订阅者的nextBlock
//如果想当一个信号被订阅，就重复播放之前所有值，需要先发送信号，在订阅信号。
//也就是先保存值，在订阅值。
// 1.创建信号
RACReplaySubject *replaySubject =[RACReplaySubject subject];
// 2.发送信号
[replaySubject sendNext:@1];
[replaySubject sendNext:@2];
// 3.订阅信号
[replaySubject subscribeNext:^(id x) {
NSLog(@"第一个订阅者接收到的数据%@",x);
}];
//订阅信号
[replaySubject subscribeNext:^(id x) {
NSLog(@"第二个订阅者接收到的数据%@",x);
}];
•RACSubject替换代理
//需求:
// 1.给当前控制器添加一个按钮，modal到另一个控制器界面
// 2.另一个控制器view中有个按钮，点击按钮，通知当前控制器
步骤一：在第二个控制器.h，添加一个RACSubject代替代理。
@interfaceTwoViewController : UIViewController
@property(nonatomic, strong) RACSubject *delegateSignal;
@end
步骤二：监听第二个控制器按钮点击
@implementationTwoViewController
-(IBAction)notice:(id)sender {
//通知第一个控制器，告诉它，按钮被点了
//通知代理
//判断代理信号是否有值
if (self.delegateSignal) {
//有值，才需要通知
[self.delegateSignal sendNext:nil];
}
}
@end
步骤三：在第一个控制器中，监听跳转按钮，给第二个控制器的代理信号赋值，并且监听.
@implementationOneViewController
-(IBAction)btnClick:(id)sender {
//创建第二个控制器
TwoViewController *twoVc =[[TwoViewController alloc] init];
//设置代理信号
twoVc.delegateSignal = [RACSubjectsubject];
//订阅代理信号
[twoVc.delegateSignal subscribeNext:^(id x){
NSLog(@"点击了通知按钮");
}];
//跳转到第二个控制器
[self presentViewController:twoVcanimated:YES completion:nil];
}
@end
4.5RACTuple:元组类,类似NSArray,用来包装值.(好比数据库表里的各列对应不同的属性，那么它的每一行对应一个元组).
4.6RACSequence:RAC中的集合类，用于代替NSArray,NSDictionary,可以使用它来快速遍历数组和字典。
使用场景：1.字典转模型
RACSequence和RACTuple简单使用
// 1.遍历数组
NSArray *numbers = @[@1,@2,@3,@4];
//这里其实是三步
//第一步:把数组转换成集合RACSequence numbers.rac_sequence
//第二步:把集合RACSequence转换RACSignal信号类,numbers.rac_sequence.signal
//第三步:订阅信号，激活信号，会自动把集合中的所有值，遍历出来。
[numbers.rac_sequence.signalsubscribeNext:^(id x) {
NSLog(@"%@",x);
}];
// 2.遍历字典,遍历出来的键值对会包装成RACTuple(元组对象)
NSDictionary *dict =@{@"name":@"xmg",@"age":@18};
[dict.rac_sequence.signalsubscribeNext:^(RACTuple *x) {
//解包元组，会把元组的值，按顺序给参数里面的变量赋值
RACTupleUnpack(NSString *key,NSString*value) = x;
//相当于以下写法
//NSString *key = x[0];
//NSString *value = x[1];
NSLog(@"%@ %@",key,value);
}];
// 3.字典转模型
// 3.1 OC写法
NSString *filePath = [[NSBundle mainBundle]pathForResource:@"flags.plist" ofType:nil];
NSArray *dictArr = [NSArrayarrayWithContentsOfFile:filePath];
NSMutableArray *items = [NSMutableArrayarray];
for (NSDictionary *dict in dictArr) {
FlagItem *item = [FlagItemflagWithDict:dict];
[items addObject:item];
}
// 3.2 RAC写法
NSString *filePath = [[NSBundle mainBundle]pathForResource:@"flags.plist" ofType:nil];
NSArray *dictArr = [NSArrayarrayWithContentsOfFile:filePath];
NSMutableArray *flags = [NSMutableArrayarray];
_flags = flags;
// rac_sequence注意点：调用subscribeNext，并不会马上执行nextBlock，而是会等一会。
[dictArr.rac_sequence.signalsubscribeNext:^(id x) {
//运用RAC遍历字典，x：字典
FlagItem *item = [FlagItemflagWithDict:x];
[flags addObject:item];
}];
NSLog(@"%@",NSStringFromCGRect([UIScreenmainScreen].bounds));
// 3.3 RAC高级写法:
NSString *filePath = [[NSBundle mainBundle]pathForResource:@"flags.plist" ofType:nil];
NSArray *dictArr = [NSArrayarrayWithContentsOfFile:filePath];
// map:映射的意思，目的：把原始值value映射成一个新值
// array:把集合转换成数组
//底层实现：当信号被订阅，会遍历集合中的原始值，映射成新值，并且保存到新的数组里。
NSArray *flags = [[dictArr.rac_sequencemap:^id(id value) {
return [FlagItem flagWithDict:value];
}] array];
4.7RACCommand:RAC中用于处理事件的类，可以把事件如何处理,事件中的数据如何传递，包装到这个类中，他可以很方便的监控事件的执行过程。
使用场景:监听按钮点击，网络请求
RACCommand简单使用
//一、RACCommand使用步骤:
//1.创建命令initWithSignalBlock:(RACSignal* (^)(id input))signalBlock
//2.在signalBlock中，创建RACSignal，并且作为signalBlock的返回值
//3.执行命令- (RACSignal *)execute:(id)input
//二、RACCommand使用注意:
//1.signalBlock必须要返回一个信号，不能传nil.
//2.如果不想要传递信号，直接创建空的信号[RACSignal empty];
// 3.RACCommand中信号如果数据传递完，必须调用[subscriber sendCompleted]，这时命令才会执行完毕，否则永远处于执行中。
// 4.RACCommand需要被强引用，否则接收不到RACCommand中的信号，因此RACCommand中的信号是延迟发送的。
//三、RACCommand设计思想：内部signalBlock为什么要返回一个信号，这个信号有什么用。
// 1.在RAC开发中，通常会把网络请求封装到RACCommand，直接执行某个RACCommand就能发送请求。
// 2.当RACCommand内部请求到数据的时候，需要把请求的数据传递给外界，这时候就需要通过signalBlock返回的信号传递了。
//四、如何拿到RACCommand中返回信号发出的数据。
// 1.RACCommand有个执行信号源executionSignals，这个是signal of signals(信号的信号),意思是信号发出的数据是信号，不是普通的类型。
// 2.订阅executionSignals就能拿到RACCommand中返回的信号，然后订阅signalBlock返回的信号，就能获取发出的值。
//五、监听当前命令是否正在执行executing
//六、使用场景,监听按钮点击，网络请求
// 1.创建命令
RACCommand *command = [[RACCommand alloc]initWithSignalBlock:^RACSignal *(id input) {
NSLog(@"执行命令");
//创建空信号,必须返回信号
//return [RACSignal empty];
// 2.创建信号,用来传递数据
return [RACSignalcreateSignal:^RACDisposable *(id subscriber) {
[subscriber sendNext:@"请求数据"];
//注意：数据传递完，最好调用sendCompleted，这时命令才执行完毕。
[subscriber sendCompleted];
return nil;
}];
}];
//强引用命令，不要被销毁，否则接收不到数据
_conmmand = command;
// 3.订阅RACCommand中的信号
[command.executionSignalssubscribeNext:^(id x) {
[x subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
}];
// RAC高级用法
//switchToLatest:用于signal of signals，获取signal of signals发出的最新信号,也就是可以直接拿到RACCommand中的信号
[command.executionSignals.switchToLatestsubscribeNext:^(id x) {
NSLog(@"%@",x);
}];
// 4.监听命令是否执行完毕,默认会来一次(会先检测到之前的状态是执行完成)，可以直接跳过，skip表示跳过第一次信号。
[[command.executing skip:1]subscribeNext:^(id x) {
if ([x boolValue] == YES) {
//正在执行
NSLog(@"正在执行");
}else{
//执行完成
NSLog(@"执行完成");
}
}];
// 5.执行命令
[self.conmmand execute:@1];
4.8RACMulticastConnection:用于当一个信号，被多次订阅时，为了保证创建信号时，避免多次调用创建信号中的block，造成副作用，可以使用这个类处理。
使用注意:RACMulticastConnection通过RACSignal的-publish或者-muticast:方法创建.
RACMulticastConnection简单使用:
//
RACMulticastConnection使用步骤:
//1.创建信号+ (RACSignal *)createSignal:(RACDisposable *
(^)(id 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就能解决.
// 1.创建请求信号
RACSignal *signal = [RACSignal createSignal:^RACDisposable*(id subscriber) {
NSLog(@"发送请求");
return nil;
}];
// 2.订阅信号
[signal subscribeNext:^(id x) {
NSLog(@"接收数据");
}];
// 2.订阅信号
[signal subscribeNext:^(id x) {
NSLog(@"接收数据");
}];
// 3.运行结果，会执行两遍发送请求，也就是每次订阅都会发送一次请求
// RACMulticastConnection:解决重复请求问题
// 1.创建信号
RACSignal *signal = [RACSignal createSignal:^RACDisposable*(id subscriber) {
NSLog(@"发送请求");
[subscriber sendNext:@1];
return nil;
}];
// 2.创建连接
RACMulticastConnection *connect = [signalpublish];
// 3.订阅信号，
//注意：订阅信号，也不能激活信号，只是保存订阅者到数组，必须通过连接,当调用连接，就会一次性调用所有订阅者的sendNext:
[connect.signal subscribeNext:^(id x) {
NSLog(@"订阅者一信号");
}];
[connect.signal subscribeNext:^(id x) {
NSLog(@"订阅者二信号");
}];
// 4.连接,激活信号
[connect connect];
4.9RACScheduler:信号调度器，是一个线性执行队列，rac中的信号可以在RACScheduler上执行任务、发送结果，底层用GCD封装的。
4.9.1包含6个实例化方法：都是用来生成一个queue的
//是一个会立即执行传入的代码块的调度器
+(RACScheduler *)immediateScheduler;
//immediateScheduler底层实现就是生成了一个RACImmediateScheduler的单例。
RACImmediateScheduler是继承自RACScheduler
//获得主线程调度器
+(RACScheduler *)mainThreadScheduler;
//获取当前线程调度器
+
(RACScheduler *)currentScheduler;
//以下3个方法实质都是是创建了一个Global Dispatch Queue，对应的属于Concurrent Dispatch Queue。
+(RACScheduler*)schedulerWithPriority:(RACSchedulerPriority)priority
name:(NSString *)name;//方法可以指定线程的优先级和名字
+
(RACScheduler *)schedulerWithPriority:(RACSchedulerPriority)priority;//方法只能执行优先级，名字为默认的
+
(RACScheduler *)scheduler;//方法创建出来的queue的优先级是默认的，名字也是默认的
4.9.2几个常用的用于调度、执行任务的方法:
//会立刻执行传入的block
-(RACDisposable *)schedule:(void(^)(void))block;
//会将当前线程休眠到指定时间后执行block
-(RACDisposable *)after:(NSDate *)date schedule:(void(^)(void))block;
//当前线程休眠date时间之后执行，然后每隔interval时间重复执行,leeway这个参数是为dispatch source指定一个期望的定时器事件精度，让系统能够灵活地管理并唤醒内核。例如系统可以使用leeway值来提前或延迟触发定时器，使其更好地与其它系统事件结合。创建自己的定时器时，应该尽量指定一个leeway值。不过就算指定leeway值为0，也不能完完全全期望定时器能够按照精确的纳秒来触发事件
-(RACDisposable *)after:(NSDate *)date repeatingEvery:(NSTimeInterval)intervalwithLeeway:(NSTimeInterval)leeway schedule:(void(^)(void))block;
4.9.3RACScheduler的使用举例：
//1.线程的切换：
deliverOn：在设置的调度中发送信号值,但操作封包依然在原来的调度里进行
//创建信号
RACSignal * signal = [RACSignal createSignal:^RACDisposable*(id subscriber) {
NSLog(@"sendTestSignal%@",[NSThread currentThread]);
[subscriber sendNext:@1];
[subscriber sendCompleted];
return [RACDisposable disposableWithBlock:^{
}];
}];
//订阅信号
//要想放在主线程执行只要将[RACScheduler scheduler]更换为[RACScheduler mainThreadScheduler]
[[self.testSignaldeliverOn:[RACScheduler scheduler]] subscribeNext:^(id x) {
NSLog(@"receiveSignal%@",[NSThread currentThread]);
}];
打印结果如下
2016-09-02 09:48:59.697 Signal processing[1686:22894]sendTestSignal{number = 1, name = main}
2016-09-0209:48:59.697 Signal processing[1686:24680] receiveSignal{number = 3, name = (null)}
subscribeOn：在设置的调度中发送信号和执行封包里的操作
[[[RACSignal createSignal:^RACDisposable *(idsubscriber) {
NSLog(@"sendSignal%@",[NSThread currentThread]);
[subscriber sendNext:@1];
return [RACDisposabledisposableWithBlock:^{
}];
}]subscribeOn:[RACScheduler scheduler]] subscribeNext:^(id x) {
NSLog(@"receiveSignal%@",[NSThread currentThread]);
}];
打印结果如下
2016-09-02 09:54:47.819 Signal processing[1778:54504] sendSignal
0x7fde7adb4e00>{number = 2, name = (null)}
2016-09-02 09:54:47.819 Signal processing[1778:54504]
receiveSignal{number = 2, name = (null)}
2.与时间相关的操作会用到
timeout：超时，可以让一个信号在一定的时间后，自动报错。（我们项目中网络请求超时问题没有处理）
RACSignal*signal = [[RACSignal createSignal:^RACDisposable *(idsubscriber) {
return nil;
}]
timeout:1 onScheduler:[RACScheduler
currentScheduler]];
[signalsubscribeNext:^(id x) {
NSLog(@"%@",x);
}error:^(NSError *error) {
// 1秒后会自动调用
NSLog(@"%@",error);
}];
interval定时：每隔一段时间发出信号
[[RACSignalinterval:1 onScheduler:[RACScheduler currentScheduler]] subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
在RACSignal+Operations很作操作方法中都会调用RACScheduler的实例化方法，我们外部直接去调用的比较少，大多都被封装进去了，比如：
-
(RACSignal *)delay:(NSTimeInterval)interval；
+(RACSignal *)interval:(NSTimeInterval)interval onScheduler:(RACScheduler*)scheduler
-(RACSignal *)timeout:(NSTimeInterval)interval onScheduler:(RACScheduler*)scheduler { }
-(RACSignal *)deliverOn:(RACScheduler *)scheduler { }
-(RACSignal *)subscribeOn:(RACScheduler *)scheduler { }
RACScheduler底层原理参考：
http://www.open-open.com/lib/view/open1487381068466.html
http://www.jianshu.com/p/980ffdf3ed8c
5.ReactiveCocoa常见操作方法介绍
5.1 ReactiveCocoa操作须知:
所有的信号（RACSignal）都可以进行操作处理，因为所有操作方法都定义在RACStream.h中，因此只要继承RACStream就有了操作处理方法
5.2ReactiveCocoa操作思想:
•运用的是Hook（钩子）思想，Hook是一种用于改变API(应用程序编程接口：方法)执行结果的技术.
•Hook用处：截获API调用的技术。
Hook原理：在每次调用一个API返回结果之前，先执行你自己的方法，改变结果的输出。
5.3ReactiveCocoa核心方法bind
//假设想监听文本框的内容，并且在每次输出结果的时候，都在文本框的内容拼接一段文字“输出：”
//方式一:在返回结果后，拼接。
[_textField.rac_textSignalsubscribeNext:^(id x) {
NSLog(@"输出:%@",x);
}];
//方式二:在返回结果前，拼接，使用RAC中bind方法做处理。
// bind方法参数:需要传入一个返回值是RACStreamBindBlock的block参数
//
RACStreamBindBlock是一个block的类型，返回值是信号，参数（value,stop），因此参数的block返回值也是一个block。
//
RACStreamBindBlock:
//参数一(value):表示接收到信号的原始值，还没做处理
//参数二(*stop):用来控制绑定Block，如果*stop = yes,那么就会结束绑定。
//返回值：信号，做好处理，在通过这个信号返回出去，一般使用RACReturnSignal,需要手动导入头文件RACReturnSignal.h。
// bind方法使用步骤:
// 1.传入一个返回值RACStreamBindBlock的block。
// 2.描述一个RACStreamBindBlock类型的bindBlock作为block的返回值。
// 3.描述一个返回结果的信号，作为bindBlock的返回值。
//注意：在bindBlock中做信号结果的处理。
//底层实现:
// 1.源信号调用bind,会重新创建一个绑定信号。
// 2.当绑定信号被订阅，就会调用绑定信号中的didSubscribe，生成一个bindingBlock。
// 3.当源信号有内容发出，就会把内容传递到bindingBlock处理，调用bindingBlock(value,stop)
// 4.调用bindingBlock(value,stop)，会返回一个内容处理完成的信号（RACReturnSignal）。
// 5.订阅RACReturnSignal，就会拿到绑定信号的订阅者，把处理完成的信号内容发送出来。
//注意:不同订阅者，保存不同的nextBlock，看源码的时候，一定要看清楚订阅者是哪个。
//这里需要手动导入#import ，才能使用RACReturnSignal。
[[_textField.rac_textSignalbind:^RACStreamBindBlock{
//什么时候调用:
// block作用:表示绑定了一个信号.
return ^RACStream *(id value, BOOL*stop){
//什么时候调用block:当信号有新的值发出，就会来到这个block。
// block作用:做返回值的处理
//做好处理，此处可以实现一些比较猥琐的操作，然后通过信号返回出去.
return [RACReturnSignalreturn:[NSString stringWithFormat:@"输出:%@",value]];
};
}] subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
5.4ReactiveCocoa操作方法之映射(flattenMap,Map)
flattenMap，Map用于把源信号内容映射成新的内容。
flattenMap简单使用
//监听文本框的内容改变，把结构重新映射成一个新值.
//flattenMap作用:把源信号的内容映射成一个新的信号，信号可以是任意类型。
// flattenMap使用步骤:
// 1.传入一个block，block类型是返回值RACStream，参数value
// 2.参数value就是源信号的内容，拿到源信号的内容做处理
// 3.包装成RACReturnSignal信号，返回出去。
// flattenMap底层实现:
// 0.flattenMap内部调用bind方法实现的,flattenMap中block的返回值，会作为bind中bindBlock的返回值。
// 1.当订阅绑定信号，就会生成bindBlock。
// 2.当源信号发送内容，就会调用bindBlock(value, *stop)
// 3.调用bindBlock，内部就会调用flattenMap的block，flattenMap的block作用：就是把处理好的数据包装成信号。
// 4.返回的信号最终会作为bindBlock中的返回信号，当做bindBlock的返回信号。
// 5.订阅bindBlock的返回信号，就会拿到绑定信号的订阅者，把处理完成的信号内容发送出来。
[[_textField.rac_textSignalflattenMap:^RACStream *(id value) {
// block什么时候:源信号发出的时候，就会调用这个block。
// block作用:改变源信号的内容。
//返回值：绑定信号的内容.
return
[RACReturnSignal return:[NSString stringWithFormat:@"输出:%@",value]];
}] subscribeNext:^(id x) {
//订阅绑定信号，每当源信号发送内容，做完处理，就会调用这个block。
NSLog(@"%@",x);
}];
Map简单使用:
//监听文本框的内容改变，把结构重新映射成一个新值.
//Map作用:把源信号的值映射成一个新的值
// Map使用步骤:
// 1.传入一个block,类型是返回对象，参数是value
// 2.value就是源信号的内容，直接拿到源信号的内容做处理
// 3.把处理好的内容，直接返回就好了，不用包装成信号，返回的值，就是映射的值。
// Map底层实现:
// 0.Map底层其实是调用flatternMap,Map中block中的返回的值会作为flatternMap中block中的值。
// 1.当订阅绑定信号，就会生成bindBlock。
// 3.当源信号发送内容，就会调用bindBlock(value, *stop)
// 4.调用bindBlock，内部就会调用flattenMap的block
// 5.flattenMap的block内部会调用Map中的block，把Map中的block返回的内容包装成返回的信号。
// 5.返回的信号最终会作为bindBlock中的返回信号，当做bindBlock的返回信号。
// 6.订阅bindBlock的返回信号，就会拿到绑定信号的订阅者，把处理完成的信号内容发送出来。
[[_textField.rac_textSignalmap:^id(id value) {
//当源信号发出，就会调用这个block，修改源信号的内容
//返回值：就是处理完源信号的内容。
return
[NSString stringWithFormat:@"输出:%@",value];
}]subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
•FlatternMap和Map的区别
◦1.FlatternMap中的Block返回信号。
◦2.Map中的Block返回对象。
◦3.开发中，如果信号发出的值不是信号，映射一般使用Map
◦4.开发中，如果信号发出的值是信号，映射一般使用FlatternMap。
•总结：signalOfsignals用FlatternMap。
//创建信号中的信号
RACSubject *signalOfsignals = [RACSubjectsubject];
RACSubject *signal = [RACSubject subject];
[[signalOfsignals flattenMap:^RACStream *(id value) {
//当signalOfsignals的signals发出信号才会调用
return value;
}] subscribeNext:^(id x) {
//只有signalOfsignals的signal发出信号才会调用，因为内部订阅了bindBlock中返回的信号，也就是flattenMap返回的信号。
//也就是flattenMap返回的信号发出内容，才会调用。
NSLog(@"%@aaa",x);
}];
//信号的信号发送信号
[signalOfsignals sendNext:signal];
//信号发送内容
[signal sendNext:@1];
5.5 ReactiveCocoa操作方法之组合。
concat:按一定顺序拼接信号，当多个信号发出的时候，有顺序的接收信号。
RACSignal *signalA= [RACSignal createSignal:^RACDisposable *(id subscriber){
[subscriber sendNext:@1];
[subscriber sendCompleted];
return nil;
}];
RACSignal *signalB = [RACSignalcreateSignal:^RACDisposable *(id subscriber) {
[subscriber sendNext:@2];
return nil;
}];
//把signalA拼接到signalB后，signalA发送完成，signalB才会被激活。
RACSignal *concatSignal =[signalA concat:signalB];
//以后只需要面对拼接信号开发。
//订阅拼接的信号，不需要单独订阅signalA，signalB
//内部会自动订阅。
//注意：第一个信号必须发送完成，第二个信号才会被激活
[concatSignalsubscribeNext:^(id x) {
NSLog(@"%@",x);
}];
// concat底层实现:
// 1.当拼接信号被订阅，就会调用拼接信号的didSubscribe
// 2.didSubscribe中，会先订阅第一个源信号（signalA）
// 3.会执行第一个源信号（signalA）的didSubscribe
// 4.第一个源信号（signalA）didSubscribe中发送值，就会调用第一个源信号（signalA）订阅者的nextBlock,通过拼接信号的订阅者把值发送出来.
// 5.第一个源信号（signalA）didSubscribe中发送完成，就会调用第一个源信号（signalA）订阅者的completedBlock,订阅第二个源信号（signalB）这时候才激活（signalB）。
// 6.订阅第二个源信号（signalB）,执行第二个源信号（signalB）的didSubscribe
// 7.第二个源信号（signalA）didSubscribe中发送值,就会通过拼接信号的订阅者把值发送出来.
then:用于连接两个信号，当第一个信号完成，才会连接then返回的信号。
•//注意使用then，之前信号的值会被忽略掉.
•//底层实现：1、先过滤掉之前的信号发出的值。2.使用concat连接then返回的信号
[[[RACSignal createSignal:^RACDisposable*(id subscriber) {
[subscriber sendNext:@1];
[subscriber sendCompleted];
return nil;
}]then:^RACSignal *{
return [RACSignal createSignal:^RACDisposable*(id subscriber) {
[subscriber sendNext:@2];
return nil;
}];
}]subscribeNext:^(id x) {
//只能接收到第二个信号的值，也就是then返回信号的值
NSLog(@"%@",x);
}];
merge:把多个信号合并为一个信号，任何一个信号有新值的时候就会调用
注意区别concat：concat的信号有先后顺序，必须要前面的信号先发出后面的信号才会被激活
//创建多个信号
RACSignal *signalA= [RACSignal createSignal:^RACDisposable *(id subscriber){
[subscriber sendNext:@1];
return nil;
}];
RACSignal *signalB = [RACSignalcreateSignal:^RACDisposable *(id subscriber) {
[subscriber sendNext:@2];
return nil;
}];
//合并信号,任何一个信号发送数据，都能监听到.
RACSignal *mergeSignal = [signalAmerge:signalB];
[mergeSignal subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
//底层实现：
// 1.合并信号被订阅的时候，就会遍历所有信号，并且发出这些信号。
// 2.每发出一个信号，这个信号就会被订阅
// 3.也就是合并信号一被订阅，就会订阅里面所有的信号。
// 4.只要有一个信号被发出就会被监听。
zipWith:把两个信号压缩成一个信号，只有当两个信号同时发出信号内容时，并且把两个信号的内容合并成一个元组，才会触发压缩流的next事件。
RACSignal *signalA =[RACSignal createSignal:^RACDisposable *(id subscriber) {
[subscriber sendNext:@1];
return nil;
}];
RACSignal *signalB = [RACSignalcreateSignal:^RACDisposable *(id subscriber) {
[subscriber sendNext:@2];
return nil;
}];
//压缩信号A，信号B
RACSignal *zipSignal = [signalAzipWith:signalB];
[zipSignal subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
//底层实现:
// 1.定义压缩信号，内部就会自动订阅signalA，signalB
// 2.每当signalA或者signalB发出信号，就会判断signalA，signalB有没有发出个信号，有就会把最近发出的信号都包装成元组发出。
combineLatest:将多个信号合并起来，并且拿到各个信号的最新的值,必须每个合并的signal至少都有过一次sendNext，才会触发合并的信号。
RACSignal*signalA = [RACSignal createSignal:^RACDisposable *(idsubscriber) {
[subscriber sendNext:@1];
return nil;
}];
RACSignal*signalB = [RACSignal createSignal:^RACDisposable *(idsubscriber) {
[subscriber sendNext:@2];
return nil;
}];
RACSignal*combineSignal = [signalA combineLatestWith:signalB];
[combineSignalsubscribeNext:^(id x) {
NSLog(@"%@",x);
}];
•//底层实现：
•// 1.当组合信号被订阅，内部会自动订阅signalA，signalB,必须两个信号都发出内容，才会被触发。
•// 2.并且把两个信号组合成元组发出。
Zip和combineLatest区别：
Zip的合并行为是按顺序取出各个信号，然后合并成元组后信号后发出。比如有信号A和信号B，合并信号为zipSingle,zipSingle发出的条件必须是A和B都有对应顺序下的最新值发出。比如A发了信号1和信号2,而B只发了信号3，那么此时组合信号只会触发一次，因为A虽说发了2次信号，但是B只发了一次，第一次的信号从A和B中都能取到，所以会有组合信号发出，第二次B信号取不到，故第二次的组合信号不成立，不会触发组合信号，只有B再发送一次信号时能能触发第二次组合信号。
CombineLatest的合并行为是，只要A和B两个子信号都触发过一次以上，就会触发该组合信号，并且后续只要A或者B中的一个信号有新信号发出都会触发该组合信号，并且该组合信号合并的规则是一直取A或者B中当前最新的值合并成元组。
实际开发中，我们下拉刷新需要等到所有接口返回再刷新UI的时候应该用zip而不是combinLatest.
reduce聚合:用于信号发出的内容是元组，把信号发出元组的值聚合成一个值
RACSignal*signalA = [RACSignal createSignal:^RACDisposable *(idsubscriber) {
[subscriber sendNext:@1];
return nil;
}];
RACSignal*signalB = [RACSignal createSignal:^RACDisposable *(idsubscriber) {
[subscriber sendNext:@2];
return nil;
}];
//常见的用法，（先组合在聚合）。combineLatest:(id)signals
reduce:(id (^)())reduceBlock
//
reduce中的block简介:
//reduceblcok中的参数，有多少信号组合，reduceblcok就有多少参数，每个参数就是之前信号发出的内容
//
reduceblcok的返回值：聚合信号之后的内容。
RACSignal*reduceSignal = [RACSignal combineLatest:@[signalA,signalB] reduce:^id(NSNumber*num1 ,NSNumber *num2){
return [NSString stringWithFormat:@"%@%@",num1,num2];
}];
[reduceSignalsubscribeNext:^(id x) {
NSLog(@"%@",x);
}];
//底层实现:
// 1.订阅聚合信号，每次有内容发出，就会执行reduceblcok，把信号内容转换成reduceblcok返回的值。
5.6 ReactiveCocoa操作方法之过滤。
•filter:过滤信号，使用它可以获取满足条件的信号.
//过滤:
//每次信号发出，会先执行过滤条件判断.
[_textField.rac_textSignalfilter:^BOOL(NSString *value) {
return value.length > 3;
}];
•ignore:忽略完某些值的信号.
//内部调用filter过滤，忽略掉ignore的值
[[_textField.rac_textSignalignore:@"1"] subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
•distinctUntilChanged:当上一次的值和当前的值有明显的变化就会发出信号，否则会被忽略掉。
//过滤，当上一次和当前的值不一样，就会发出内容。
//在开发中，刷新UI经常使用，只有两次数据不一样才需要刷新
[[_textField.rac_textSignaldistinctUntilChanged] subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
•take:从开始一共取N次的信号
//
1、创建信号
RACSubject*signal = [RACSubject subject];
//
2、处理信号，订阅信号
[[signaltake:1] subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
//
3.发送信号
[signalsendNext:@1];
[signalsendNext:@2];
◦takeLast:取最后N次的信号,前提条件，订阅者必须调用完成，因为只有完成，就知道总共有多少信号.
//
1、创建信号
RACSubject*signal = [RACSubject subject];
//
2、处理信号，订阅信号
[[signaltakeLast:1] subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
//
3.发送信号
[signalsendNext:@1];
[signalsendNext:@2];
[signalsendCompleted];//必须调完成
◦takeUntil:(RACSignal *):获取信号直到某个信号执行完成
//监听文本框的改变直到当前对象被销毁
[_textField.rac_textSignaltakeUntil:self.rac_willDeallocSignal];
◦skip:(NSUInteger):跳过几个信号,不接受。
//表示输入第一次，不会被监听到，跳过第一次发出的信号
[[_textField.rac_textSignalskip:1] subscribeNext:^(id x) {
NSLog(@"%@",x);
}];
◦switchToLatest:用于signalOfSignals（信号的信号），有时候信号也会发出信号，会在signalOfSignals中，获取signalOfSignals发送的最新信号。
RACSubject*signalOfSignals = [RACSubject subject];
RACSubject*signal = [RACSubject subject];
//获取信号中信号最近发出信号，订阅最近发出的信号。
//注意switchToLatest：只能用于信号中的信号
[signalOfSignals.switchToLatestsubscribeNext:^(id x) {
NSLog(@"%@",x);
}];
[signalOfSignalssendNext:signal];
[signal sendNext:@1];
5.7 ReactiveCocoa操作方法之秩序。
•doNext:执行Next之前，会先执行这个Block
•doCompleted:执行sendCompleted之前，会先执行这个Block
[[[[RACSignalcreateSignal:^RACDisposable *(id 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);
}];
5.8 ReactiveCocoa操作方法之线程。
deliverOn:内容传递切换到制定线程中，副作用在原来线程中,把在创建信号时block中的代码称之为副作用。
subscribeOn:内容传递和副作用都会切换到制定线程中。
上文RACScheduler均有代码演示。
5.9 ReactiveCocoa操作方法之时间。
timeout：超时，可以让一个信号在一定的时间后，自动报错。
interval定时：每隔一段时间发出信号
delay延迟发送next。
上文均有代码演示。
5.10 ReactiveCocoa操作方法之重复。
retry重试：只要失败，就会重新执行创建信号中的block,直到成功.
__blockint i = 0;
[[[RACSignal createSignal:^RACDisposable*(id subscriber) {
if (i == 10) {
[subscriber sendNext:@1];
}else{
NSLog(@"接收到错误");
[subscriber sendError:nil];
}
i++;
return nil;
}] retry] subscribeNext:^(id x) {
NSLog(@"%@",x);
} error:^(NSError *error) {
}];
replay重放：当一个信号被多次订阅,反复播放内容（类似的还有replayLast，replayLazily）
具体用法比较：见文档。
throttle节流:当某个信号发送比较频繁时，可以使用节流，在某一段时间不发送信号内容，过了一段时间获取信号的最新内容发出。
需求场景：
在我们做搜索框的时候，有时候需求的时实时搜索，即用户每每输入字符，view都要求展现搜索结果。这时如果用户搜索的字符串较长，那么由于网络请求的延时可能造成UI显示错误，并且多次不必要的请求还会加大服务器的压力，这显然是不合理的，此时我们就需要用到节流。
[[[self.textFild rac_textSignal]throttle:1] subscribeNext:^(id x) {
NSLog(@"%@", x);
}];
主要技术参考资料：
