Reactivecocoa(RAC)使用学习（全）

RAC使用容易忽略掉一些细节，从而出现内存泄漏，注意⚠️

ReactiveCocoa结合了几种编程风格：

函数式编程（Functional Programming）

响应式编程（Reactive Programming）

ReactiveCocoa被描述为函数响应式编程（FRP）框架

一、常见的类学习：

1、RACSignal

    /*RACSignal：有数据产生的时候就使用
     使用步骤：1、创建信号；2、订阅信号；3、发送信号；
     */
    
    //1、创建信号（冷信号）
    RACSignal *signal = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        //有返回值的block，_Nullable可为空
        
        /*
         这个block叫didSubscribe
         调用：只要一个信号被订阅就会调用
         作用：发送数据
         */
        
        NSLog(@"信号被订阅");
        
        //3、发送数据
        [subscriber sendNext:@1];
        
        
        return nil;
    }];
    
    //2、订阅信号（热信号）
    [signal subscribeNext:^(id  _Nullable x) {
        
        /*
         nextBlock
         调用：只要订阅者发送数据就会调用
         作用：接收数据，处理数据，展示到UI上
         */
        
        //x：信号发送的内容
        
        NSLog(@"-----%@",x);
        
    }];
    
    /*
     只要订阅者调用sendNext，就会执行nextBlock
     只要订阅RACDynamicSignal类型的信号，就会执行didSubscribe
     前提条件：一定要是RACDynamicSignal，不同类型的信号，处理订阅的事情不一样
     */

2、RACSubscriber

表示订阅者的意思，用于发送信号，这是一个协议，不是一个类，只要遵守这个协议，并且实现方法才能成为订阅者。通过create创建的信号，都有一个订阅者，帮助他发送数据。

3、RACDisposable

    RACSignal *signal = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        
        //用属性保存下来，防止subscriber自动销毁
        _subscriber = subscriber;
        
        [subscriber sendNext:@123];
        
        return [RACDisposable disposableWithBlock:^{
            /*
             只要订阅取消就会来到这里
             作用：清空资源
             */
            NSLog(@"信号被取消订阅了");
        }];
    }];
    
    RACDisposable *disposable = [signal subscribeNext:^(id  _Nullable x) {
        NSLog(@"----------%@",x);
    }];
    
    /*
     默认一个信号发送完毕就会取消信号订阅
     但是只要订阅者在，就不会自动取消信号订阅
     */
    
    //手动取消订阅信号
    [disposable dispose];

4、RACSubject （代替代理）

    /*
     RACSubject:信号提供者，自己可以充当信号，又能发送信号
     
     想要某个类拥有多个类的功能，就可以继承一个类，再遵守协议，这叫做面向协议的思想
     */
    
    //1、创建信号
    RACSubject *subject = [RACSubject subject];
    
    //2、订阅信号
    //RACSubject：仅仅保存订阅者
    [subject subscribeNext:^(id  _Nullable x) {
        NSLog(@"1、接收到数据：%@",x);
    }];
    
    [subject subscribeNext:^(id  _Nullable x) {
        NSLog(@"2、接收到数据：%@",x);
    }];
    
    //3、发送数据
    [subject sendNext:@123];
    //底层实现：遍历订阅者，调用nextBlock

5、RACReplaySubject （可以先发送信号再订阅）

    //1、创建信号
    RACReplaySubject *replaySubject = [RACReplaySubject subject];
    
    //3、发送信号
    [replaySubject sendNext:@1111];
    
    //2、订阅信号
    [replaySubject subscribeNext:^(id  _Nullable x) {
        NSLog(@"%@",x);
    }];
    //遍历所有的值，拿到当前订阅者去发送数据
    
    /*
     RACReplaySubject发送数据：
     1、保存值
     2、遍历所有的订阅者，发送数据
     
     RACReplaySubject可以先发送信号再订阅
     */

6、RACMulticastConnection

用法：当一个信号，被多次订阅时，为了保证创建信号时，避免多次调用创建信号中的block，也就是请求数据的block，造成副作用，可以使用这个类处理。

使用注意:RACMulticastConnection通过RACSignal的-publish或者-muticast:方法创建.

eg：信号被多次订阅的时候，会重复请求数据

代码：


    RACSignal *s0 = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        
        NSLog(@"---请求数据");
        [subscriber sendNext:@"得到的数据"];
        
        return nil;
    }];
    
    [s0 subscribeNext:^(id  _Nullable x) {
        NSLog(@"%@",x);
    }];
    
    [s0 subscribeNext:^(id  _Nullable x) {
        NSLog(@"%@",x);
    }];

输出：

2017-07-28 10:17:37.837 RAC_learning[1180:38354] ---请求数据
2017-07-28 10:17:37.837 RAC_learning[1180:38354] 得到的数据
2017-07-28 10:17:37.837 RAC_learning[1180:38354] ---请求数据
2017-07-28 10:17:37.838 RAC_learning[1180:38354] 得到的数据

这样导致了多次请求数据，所以用RACMulticastConnection可以实现不论多少次订阅，只请求一次数据

eg:用RACMulticastConnection

    //1、创建信号
    RACSignal *signal = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        
        NSLog(@"---请求数据");
        [subscriber sendNext:@"得到的数据"];
        
        return nil;
    }];
    
    //2、把信号转换成连接类
    RACMulticastConnection *connection = signal.publish;
    //或者
    //RACMulticastConnection *connection = [signal multicast:[RACReplaySubject subject]];
    
    
    //3、订阅信号
    [connection.signal subscribeNext:^(id  _Nullable x) {
        NSLog(@"第一次获取：%@",x);
    }];
    
    [connection.signal subscribeNext:^(id  _Nullable x) {
        NSLog(@"第二次获取：%@",x);
    }];
    
    //4、连接
    [connection connect];

输出

2017-07-28 10:22:09.098 RAC_learning[1243:41311] ---请求数据
2017-07-28 10:22:09.099 RAC_learning[1243:41311] 第一次获取：得到的数据
2017-07-28 10:22:09.099 RAC_learning[1243:41311] 第二次获取：得到的数据

7、RACCommand

RAC中用于处理事件的类，可以把事件如何处理,事件中的数据如何传递，包装到这个类中，他可以很方便的监控事件的执行过程。

使用场景:监听按钮点击，网络请求

（1）==RACCommand==


    //1、创建命令
    RACCommand *command = [[RACCommand alloc] initWithSignalBlock:^RACSignal * _Nonnull(id  _Nullable input) {
        
        //得到执行命令传入参数
        NSLog(@"得到执行命令传入参数input = %@",input);
        
        return [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
            
            [subscriber sendNext:@"请求到的数据"];
            
            return nil;
        }];
        
    }];
    
    /*
      如何拿到执行命令中产生的数据
      订阅命令内部的信号
      1.方式一:直接订阅执行命令返回的信号（execute方法返回RACSignal）
      2.方式二:executionSignals:获取信号源
     */
    
    //2、执行命令
    
    //方式一:直接订阅执行命令返回的信号（execute方法返回RACSignal）  必须在执行命令之后执行
    
    /*
    RACSignal *signal = [command execute:@1];
    
    [signal subscribeNext:^(id  _Nullable x) {
        NSLog(@"%@",x);
    }];
     */
    
    //方式二:executionSignals:获取信号源  必须在执行命令之前执行
    
    /*
    [command.executionSignals subscribeNext:^(RACSignal *x) {
       //这里获取到的是RACSignal
        [x subscribeNext:^(id  _Nullable x) {
            NSLog(@"%@",x);
        }];
    }];
     */
    
    //switchToLatest：得到信号源中最新的信号
    [command.executionSignals.switchToLatest subscribeNext:^(id  _Nullable x) {
        NSLog(@"%@",x);
    }];
    
    [command execute:@1];

（2）==switchToLatest==：得到信号源中最新的信号

    // 创建信号中信号
    RACSubject *signalOfSignals = [RACSubject subject];
    RACSubject *signalA = [RACSubject subject];
    RACSubject *signalB = [RACSubject subject];
    
    //只会得到最新的发送的信号signalB
    [signalOfSignals.switchToLatest subscribeNext:^(id x) {
        
        NSLog(@"%@",x);
    }];
    
    // 发送信号
    [signalOfSignals sendNext:signalA];
    
    [signalOfSignals sendNext:signalB];

    
    [signalA sendNext:@1];
    [signalB sendNext:@"BB"];
    [signalA sendNext:@"11"];

（3）==executing==：监听事件有没有完成

    // 1.创建命令
    RACCommand *command = [[RACCommand alloc] initWithSignalBlock:^RACSignal *(id input) {
        
        NSLog(@"%@",input);
        
        return [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
            
            // 发送数据
            [subscriber sendNext:@"执行命令产生的数据"];
            
            // 主动发送完成，这样才会监听到发送完成的时候
            [subscriber sendCompleted];
            
            return nil;
        }];
    }];
    
    // 监听事件有没有完成
    [command.executing subscribeNext:^(id x) {
        if ([x boolValue] == YES) {
            // 当前正在执行
            NSLog(@"当前正在执行");
        }else{
            // 执行完成/没有执行
            NSLog(@"执行完成/没有执行");
        }
    }];
    
    
    // 2.执行命令
    [command execute:@1];

二、集合类学习

1、RACTuple

（1）当作数组用

RACTuple *tuple = [RACTuple tupleWithObjectsFromArray:@[@"123",@"456",@789]];
    
    NSString *string = tuple[0];
    
    NSLog(@"%@",string);

2、RACSequence

（1）当作数组用

NSArray *array = @[@"123",@"456",@789];
    //数组转集合
    RACSequence *sequence = array.rac_sequence;
    //集合转信号
    RACSignal *signal = sequence.signal;
    //遍历
    [signal subscribeNext:^(id  _Nullable x) {
        NSLog(@"%@",x);
    }];
    
    //简单写法------------
    [array.rac_sequence.signal subscribeNext:^(id  _Nullable x) {
        NSLog(@"%@",x);
    }];

（2）当集合用

    NSDictionary *dict = @{@"account":@"aaa",@"name":@"xmg",@"age":@18};
    [dict.rac_sequence.signal subscribeNext:^(id  _Nullable x) {
//        NSString *key = x[0];
//        NSString *value = x[1];
//        NSLog(@"%@  %@",key,value);
        
        // RACTupleUnpack:用来解析元组
        // 宏里面的参数,传需要解析出来的变量名
        // = 右边,放需要解析的元组
        RACTupleUnpack(NSString *key, NSString *value) = x;
        
        NSLog(@"%@  %@", key, value);
    }];
    
    
    NSArray *dictArr = [NSArray arrayWithContentsOfFile:[[NSBundle mainBundle] pathForResource:@"flags.plist" ofType:nil]];
    
    NSMutableArray *array = [NSMutableArray array];
    [dictArr.rac_sequence.signal subscribeNext:^(NSDictionary *dict) {
        Flag *flag = [Flag flagWithDict:dict];
        [array addObject:flag];
    }];
    
    //更高级点的用法
    NSArray *flagArr = [[dictArr.rac_sequence map:^id _Nullable(NSDictionary *dict) {
        return [Flag flagWithDict:dict];
    }] array];

三、开发中常见用法（转换成信号然后订阅）

1、代替代理:

（1）RACSubject ：可以传值

（2）rac_signalForSelector ：无法传值

[[_redView rac_signalForSelector:@selector(btnClick:)] subscribeNext:^(id x) {
    NSLog(@"控制器知道按钮被点击");
}];

2、代替KVO :

rac_valuesForKeyPath：用于监听某个对象的属性改变。

[[_redView rac_valuesForKeyPath:@"frame" observer:nil] subscribeNext:^(id x) {
    // x:修改的值
    NSLog(@"%@",x);
}];

3、监听事件:

rac_signalForControlEvents：用于监听某个事件。

    [[_btn rac_signalForControlEvents:UIControlEventTouchUpInside] subscribeNext:^(id x) {
        NSLog(@"按钮点击了");
    }];

4、代替通知:

rac_addObserverForName:用于监听某个通知。

[[[NSNotificationCenter defaultCenter] rac_addObserverForName:UIKeyboardWillShowNotification object:nil] subscribeNext:^(id x) {
        
        NSLog(@"%@",x);
    }];

5、监听文本框文字改变:

rac_textSignal:只要文本框发出改变就会发出这个信号。

[_textField.rac_textSignal subscribeNext:^(id x) {
       
        NSLog(@"%@",x);
    }];

6、处理当界面有多次请求时，需要都获取到数据时，才能展示界面

rac_liftSelector:withSignalsFromArray:

Signals:当传入的Signals(信号数组)，每一个signal都至少sendNext过一次，就会去触发第一个selector参数的方法。

使用注意：几个信号，参数一的方法就几个参数，每个参数对应信号发出的数据。


- (void)viewDidLoad {
    [super viewDidLoad];
    
    RACSignal *signal0 = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        //这里进行网络请求
        [subscriber sendNext:@"0000000"];
        return nil;
    }];
    
    RACSignal *signal1 = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        //这里进行网络请求
        [subscriber sendNext:@"1111111"];
        return nil;
    }];
    
    /*
     selector方法参数个数必须与信号数组个数一致，表示获得到的数据
     rac_liftSelector：必须信号数组中的信号都发送数据才会进入selector方法中
     */
    [self rac_liftSelector:@selector(updateUIWithOne:two:) withSignalsFromArray:@[signal0, signal1]];
    
}

- (void)updateUIWithOne:(NSString *)one two:(NSString *)two{
    
    NSLog(@"one = %@;\ntwo = %@",one,two);
    
}

四、常见的宏

1、RAC(<#TARGET, ...#>)：用于给某个对象的某个属性绑定

// 监听文本框内容

[_textField.rac_textSignal subscribeNext:^(id x) {
    _label.text = x;
}];

//使用RAC宏：    
// 用来给某个对象的某个属性绑定信号,只要产生信号内容,就会把内容给属性赋值
RAC(_label,text) = _textField.rac_textSignal;

2、RACObserve(self, name):监听某个对象的某个属性,返回的是信号

[RACObserve(self.view, frame) subscribeNext:^(id x) {
    NSLog(@"%@",x);
}];

3、@weakify(Obj)和@strongify(Obj),一般两个都是配套使用,解决循环引用问题.

//在block外使用@weakify(self)，在block內使用@strongify(self)，可以防止block内使用self出现循环引用

4、RACTuplePack：把数据包装成RACTuple（元组类）

// 包装元组
RACTuple *tuple = RACTuplePack(@1,@2);
    
NSLog(@"%@",tuple[0]);

5、RACTupleUnpack：把RACTuple（元组类）解包成对应的数据

NSDictionary *dict = @{@"account":@"aaa",@"name":@"xmg",@"age":@18};
[dict.rac_sequence.signal subscribeNext:^(id  _Nullable x) {

    // RACTupleUnpack:用来解析元组
    // 宏里面的参数,传需要解析出来的变量名
    // = 右边,放需要解析的元组
    RACTupleUnpack(NSString *key, NSString *value) = x;
    
    NSLog(@"%@  %@", key, value);
}];

五、常见操作方法

ReactiveCocoa操作思想

运用的是==Hook（钩子）思想==，Hook是一种用于改变API(应用程序编程接口：方法)执行结果的技术.
Hook用处：截获API调用的技术。
Hook原理：在每次调用一个API返回结果之前，先执行你自己的方法，改变结果的输出。

RAC开发方式：RAC中核心开发方式，也是绑定，之前的开发方式是赋值，而用RAC开发，应该把重心放在绑定，也就是可以在创建一个对象的时候，就绑定好以后想要做的事情，而不是等赋值之后在去做事情。
列如：把数据展示到控件上，之前都是重写控件的setModel方法，用RAC就可以在一开始创建控件的时候，就绑定好数据。

1、核心方法bind

一般不会使用bind方法，因为比较底层
给RAC中的信号进行绑定，只要信号一发送数据，就能监听到，从而把发送数据改成自己想要的数据

    RACSubject *subject = [RACSubject subject];
    
    RACSignal *bindSignal = [subject bind:^RACSignalBindBlock _Nonnull{
        
        return ^RACSignal *(id _Nullable value, BOOL *stop){
            
            value = [NSString stringWithFormat:@"changed:%@",value];
            
            /*
             在这里修改获取到的数据
             */
            
            return [RACReturnSignal return:value];
        };
        
    }];
    
    [bindSignal subscribeNext:^(id  _Nullable x) {
        NSLog(@"%@",x);
    }];
    
    [subject sendNext:@"数据"];

监听文本框的内容，并绑定

[[self.textField.rac_textSignal bind:^RACSignalBindBlock _Nonnull{
        return ^RACSignal *(id _Nullable value, BOOL *stop){
            value = [NSString stringWithFormat:@"输出：%@",value];
            return [RACReturnSignal return:value];
        };
    }] subscribeNext:^(id  _Nullable x) {
        NSLog(@"%@",x);
    }];

2、ReactiveCocoa操作方法之映射(flattenMap,Map)

（1）falttenMap


    //1、创建信号
    RACSubject *subject = [RACSubject subject];
    
    //2、绑定信号
    RACSignal *bindSignal = [subject flattenMap:^__kindof RACSignal * _Nullable(id  _Nullable value) {
        
        //这里的block只要原信号发送数据就会调用
        value = [NSString stringWithFormat:@"lcy:%@",value];
        
        return [RACReturnSignal return:value];
        
    }];
    
    //3、订阅信号
    [bindSignal subscribeNext:^(id  _Nullable x) {
        NSLog(@"%@",x);
    }];
    
    //4、发送数据
    [subject sendNext:@"hello"];

（2）map


    RACSubject *subject = [RACSubject subject];
    
    RACSignal *bindSignal = [subject map:^id _Nullable(id  _Nullable value) {
        //这里返回的值就是需要映射的值
        return [NSString stringWithFormat:@"dashabi:%@",value];
    }];
    
    [bindSignal subscribeNext:^(id  _Nullable x) {
        NSLog(@"%@",x);
    }];
    
    [subject sendNext:@"123123"];
    [subject sendNext:@"123123123"];

3、ReactiveCocoa操作方法之组合

（1）concat

按一定顺序拼接信号，当多个信号发出的时候，有顺序的接收信号。

==注意==：组合中第一个信号一定要调用sendComplete

    RACSignal *signalA = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        
        NSLog(@"发送A的数据");
        
        [subscriber sendNext:@"hello A"];
        
        [subscriber sendCompleted];
        
        return nil;
    }];
    
    RACSignal *signalB = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        
        NSLog(@"发送B的数据");

        [subscriber sendNext:@"hello B"];

        return nil;
    }];
    
    RACSignal *concatSignal = [signalA concat:signalB];
    
    [concatSignal subscribeNext:^(id  _Nullable x) {
        NSLog(@"%@",x);
    }];

输出：

2017-07-28 16:33:57.588 RAC_learning[3169:192908] 发送A的数据
2017-07-28 16:33:57.589 RAC_learning[3169:192908] hello A
2017-07-28 16:33:57.589 RAC_learning[3169:192908] 发送B的数据
2017-07-28 16:33:57.589 RAC_learning[3169:192908] hello B

（2）then

用于连接两个信号，当第一个信号完成，才会连接then返回的信号，then会完全忽略第一个信号的数据

==注意==：组合中第一个信号一定要调用sendComplete

RACSignal *signalA = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        
        NSLog(@"发送A的数据");
        
        [subscriber sendNext:@"hello A"];
        
        [subscriber sendCompleted];
        
        return nil;
    }];
    
    RACSignal *signalB = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        
        NSLog(@"发送B的数据");

        [subscriber sendNext:@"hello B"];

        return nil;
    }];
    
    RACSignal *signal = [signalA then:^RACSignal * _Nonnull{
        return signalB;
    }];
    
    [signal subscribeNext:^(id  _Nullable x) {
        NSLog(@"%@",x);
    }];

输出：

2017-07-28 16:38:18.436 RAC_learning[3280:196164] 发送A的数据
2017-07-28 16:38:18.440 RAC_learning[3280:196164] 发送B的数据
2017-07-28 16:38:18.440 RAC_learning[3280:196164] hello B

（3）merge

把多个信号合并为一个信号，任何一个信号有新值的时候就会调用

不需要调用sendComplete

    RACSignal *signalA = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        
        NSLog(@"发送A的数据");
        
        [subscriber sendNext:@"hello A"];
        
        return nil;
    }];
    
    RACSignal *signalB = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        
        NSLog(@"发送B的数据");

        [subscriber sendNext:@"hello B"];

        return nil;
    }];
    
    RACSignal *signalC = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        
        return nil;
    }];
    
    RACSignal *signal = [[signalA merge:signalB] merge:signalC];
    
    [signal subscribeNext:^(id  _Nullable x) {
        NSLog(@"%@",x);
    }];

输出：

2017-07-28 16:46:06.471 RAC_learning[3563:202620] 发送A的数据
2017-07-28 16:46:06.471 RAC_learning[3563:202620] hello A
2017-07-28 16:46:06.471 RAC_learning[3563:202620] 发送B的数据
2017-07-28 16:46:06.472 RAC_learning[3563:202620] hello B

（4）zipWith

把两个信号压缩成一个信号，只有当两个信号同时发出信号内容时，并且把两个信号的内容合并成一个==元组==（RACTuple），才会触发压缩流的next事件

RACSignal *signalA = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        
        NSLog(@"发送A的数据");
        
        [subscriber sendNext:@"hello A"];
        
        return nil;
    }];
    
    RACSignal *signalB = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        
        NSLog(@"发送B的数据");

        [subscriber sendNext:@"hello B"];

        return nil;
    }];
    
    RACSignal *signal = [signalA zipWith:signalB];
    
    [signal subscribeNext:^(id  _Nullable x) {
        NSLog(@"%@",x);
    }];

输出：

2017-07-28 16:52:44.200 RAC_learning[3630:205690] 发送A的数据
2017-07-28 16:52:44.201 RAC_learning[3630:205690] 发送B的数据
2017-07-28 16:52:44.204 RAC_learning[3630:205690] <RACTwoTuple: 0x6000000173b0> (
    "hello A",
    "hello B"
)

（5）combineLatest

将多个信号合并起来，并且拿到各个信号的最新的值,必须每个合并的signal至少都有过一次sendNext，才会触发合并的信号

（6）reduce

用于信号发出的内容是元组，把信号发出元组的值聚合成一个值

RACSignal *signal = [RACSignal combineLatest:@[self.nameTF.rac_textSignal, self.passwordTF.rac_textSignal] reduce:^id _Nullable(NSString *name, NSString *password){
        
        NSLog(@"%@  ooooo  %@",name, password);
        
        return @(name.length && password.length);
    }];

//    [signal subscribeNext:^(id  _Nullable x) {
//        NSLog(@"得到的数据：%@",x);
//    }];
    
    //使登录按钮在用户名和密码框都有数据的时候才会调用
    RAC(self.loginButton, enabled) = signal;

4、ReactiveCocoa操作方法之过滤

（1）filter

过滤信号，使用它可以获取满足条件的信号

RACSignal *signal = [self.nameTF.rac_textSignal filter:^BOOL(NSString * _Nullable value) {
        
        //表示当文本框输入的长度超过六位的时候

        return value.length > 6;
        
    }];
    
    [signal subscribeNext:^(id  _Nullable x) {
        //只有满足条件的时候才会进入这个block

        NSLog(@"%@",x);
    }];

（2）ignore

忽略完某些值的信号.

[[self.nameTF.rac_textSignal ignore:@"000"] subscribeNext:^(NSString * _Nullable x) {
       //忽略了字符串是000的值
       NSLog(@"%@",x);
    }];

（3）distinctUntilChanged

当上一次的值和当前的值有明显的变化就会发出信号，否则会被忽略掉

[[self.nameTF.rac_textSignal distinctUntilChanged] subscribeNext:^(NSString * _Nullable x) {
        NSLog(@"%@",x);
    }];

（4）take

从开始一共取N次的信号

[[self.nameTF.rac_textSignal take:3] subscribeNext:^(NSString * _Nullable x) {
        NSLog(@"%@",x);
    }];

// 1、创建信号
RACSubject *signal = [RACSubject subject];

// 2、处理信号，订阅信号
[[signal take:1] subscribeNext:^(id x) {

  NSLog(@"%@",x);
}];

// 3.发送信号
[signal sendNext:@1];

[signal sendNext:@2];

（5）takeLast

取最后N次的信号
==前提条件==：订阅者必须调用完成，因为只有完成，就知道总共有多少信号
==注意==：一定要调用sendComplete，不然订阅者不知道有多少

RACSubject *subject = [RACSubject subject];
    
    [[subject takeLast:3] subscribeNext:^(id  _Nullable x) {
        NSLog(@"%@",x);
    }];
    
    [subject sendNext:@1];
    [subject sendNext:@2];
    [subject sendNext:@3];
    [subject sendNext:@4];
    [subject sendNext:@5];

    
    [subject sendCompleted];

（6）takeUntil

获取信号直到执行完这个信号

RACSubject *subject = [RACSubject subject];
    
    RACSubject *signal = [RACSubject subject];
    
    [[subject takeUntil:signal] subscribeNext:^(id  _Nullable x) {
        NSLog(@"%@",x);
    }];
    
    [subject sendNext:@1];
    [subject sendNext:@2];
    
    /*
    sendNext或者sendComplete都可以截止
    sendError不可以
    */
    [signal sendCompleted];
    
    
    [subject sendNext:@3];
    [subject sendNext:@4];
    [subject sendNext:@5];
    
    
    [subject sendCompleted];

// 监听文本框的改变，直到当前对象被销毁
[_textField.rac_textSignal takeUntil:self.rac_willDeallocSignal];

（7）skip:(NSUInteger)

跳过几个信号,不接受

[[self.nameTF.rac_textSignal skip:3] subscribeNext:^(NSString * _Nullable x) {
        NSLog(@"%@",x);
    }];

5、ReactiveCocoa操作方法之秩序

doNext: 执行Next之前，会先执行这个Block

doCompleted: 执行sendCompleted之前，会先执行这个Block

[[[[RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        [subscriber sendNext:@"hahaha"];
        [subscriber sendCompleted];
        return nil;
    }] doNext:^(id  _Nullable x) {
        NSLog(@"doNext");
    }] doCompleted:^{
        NSLog(@"doComplete");
    }] subscribeNext:^(id  _Nullable x) {
        NSLog(@"%@",x);
    }];

输出：

2017-07-28 18:12:56.704 RAC_learning[5256:261194] doNext
2017-07-28 18:12:56.705 RAC_learning[5256:261194] hahaha
2017-07-28 18:12:56.705 RAC_learning[5256:261194] doComplete

6、ReactiveCocoa操作方法之线程

deliverOn: 内容传递切换到制定线程中，副作用在原来线程中,把在创建信号时block中的代码称之为副作用。

subscribeOn: 内容传递和副作用都会切换到制定线程中。

7、ReactiveCocoa操作方法之时间

（1）timeout

超时，可以让一个信号在一定的时间后，自动报错

RACSignal *signal = [[RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
        return nil;
    }] timeout:1 onScheduler:[RACScheduler currentScheduler]];
    
    [signal subscribeNext:^(id x) {
        
        NSLog(@"%@",x);
    } error:^(NSError *error) {
        // 1秒后会自动调用
        NSLog(@"%@",error);
    }];

（2）interval

定时，每隔一段时间发出信号

RACSignal *signal = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        [subscriber sendNext:@"123123123"];
        return nil;
    }];
    
    [[RACSignal interval:2.0 onScheduler:[RACScheduler currentScheduler]] subscribeNext:^(NSDate * _Nullable x) {
        NSLog(@"%@",x);
        [signal subscribeNext:^(id  _Nullable x) {
            NSLog(@"%@",x);
        }];
        
    }];

（3）delay

延迟发送next

[[[RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        [subscriber sendNext:@"123123123"];
        return nil;
    }] delay:2] subscribeNext:^(id  _Nullable x) {
        NSLog(@"%@",x);
    }];

8、ReactiveCocoa操作方法之重复

（1）retry重试

只要失败，就会重新执行创建信号中的block,直到成功.

__block int i = 0;
    [[[RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {

            if (i == 10) {
                [subscriber sendNext:@1];
            }else{
                NSLog(@"接收到错误");
                [subscriber sendError:nil];
            }
            i++;

        return nil;

    }] retry] subscribeNext:^(id x) {

        NSLog(@"%@",x);

    } error:^(NSError *error) {


    }];

（2）replay重放

当一个信号被多次订阅,反复播放内容

RACSignal *signal = [[RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
    //只会进入这个block一次，不会反复进入

        [subscriber sendNext:@1];
        [subscriber sendNext:@2];

        return nil;
    }] replay];

    [signal subscribeNext:^(id x) {

        NSLog(@"第一个订阅者%@",x);

    }];

    [signal subscribeNext:^(id x) {

        NSLog(@"第二个订阅者%@",x);

    }];

（3）throttle节流

当某个信号发送比较频繁时，可以使用节流，在某一段时间不发送信号内容，过了一段时间获取信号的最新内容发出。
R

ACSubject *signal = [RACSubject subject];

    _signal = signal;

    // 节流，在一定时间（1秒）内，不接收任何信号内容，过了这个时间（1秒）获取最后发送的信号内容发出。
    [[signal throttle:1] subscribeNext:^(id x) {

        NSLog(@"%@",x);
    }];

最后编辑于：2018.02.02 10:16:56

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 204,053评论 6赞 478
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 85,527评论 2赞 381
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 150,779评论 0赞 337
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 54,685评论 1赞 276
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 63,699评论 5赞 366
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 48,609评论 1赞 281
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 37,989评论 3赞 396
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,654评论 0赞 258
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 40,890评论 1赞 298
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,634评论 2赞 321
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 37,716评论 1赞 330
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,394评论 4赞 319
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 38,976评论 3赞 307
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 29,950评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,191评论 1赞 260
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 44,849评论 2赞 349
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,458评论 2赞 342