ReactiveCocoa学习笔记整理(二)

此文章是ReactiveCocoa学习笔记的第二篇，未阅读第一篇的童鞋，请先查阅第一篇ReactiveCocoa学习笔记整理(一) 。好的，废话不多说，上一篇中我们简单的了解了RAC的概念，编程思想以及RACSignal这个基类的简单应用。我们接着上一篇的内容继续探寻RAC学习之路。

三. RACSubject基础知识点

首先，我们介绍另一个使用非常频繁的类，RACSubject，我们将会从它的概念，使用步骤，底层实现入手，慢慢剖析，然后通过几个简单的小例子应用一下下。

1. RACSubject基本概念以及使用步骤

RACSubject被称为信号提供者，它既可以自己充当信号，又能够发送信号。最常用的使用场景就是用来代替代理，有了它，就没必要定义代理了。接下来，我们看一下RACSubject的具体使用步骤:

创建信号 [RACSubject subject]，跟RACSiganl不一样，创建信号时没有block。
订阅信号 - (RACDisposable *)subscribeNext:(void (^)(id x))nextBlock
发送信号 sendNext:(id)value

2. RACSubject底层实现以及简单应用

RACSubject的底层实现和RACSignal不一样，简单的介绍一下RACSubject的实现步骤。

调用subscribeNext订阅信号，只是把订阅者保存起来，并且订阅者的nextBlock已经赋值了
调用sendNext发送信号，遍历刚刚保存的所有订阅者，一个一个调用订阅者的nextBlock
在这篇文章就不展开描述了，有兴趣的童鞋可以查阅ReactiveCocoa深入理解，里面有关于底层实现的详细剖析。这里需要对持有订阅者解释一下，由于RACSubject是热信号, 为了保证未来有事件发生的时候, 订阅者可以收到信息, 所以需要持有订阅者。好了，我们用简单的小实例探究一下，请看如下代码:

RACSubject *subject=[RACSubject subject];
    
    [subject subscribeNext:^(id x) {
        NSLog(@"订阅者1的值%@",x);
    }];
    
    [subject sendNext:@"wujunyang"];
    
    [subject subscribeNext:^(id x) {
        NSLog(@"订阅者2的值%@",x);
    }];
    
    [subject sendNext:@"cnblogs"];
    
//    输出：
//    订阅者1的值wujunyang
//    订阅者1的值cnblogs
//    订阅者2的值cnblogs

通过以后的代码输出，我们可以很明确的得到结论：RACSubject 发送过了sendNext，下面再去监听它是没有效果，即RACSubject是热信号的本质。
上面也提到了，RACSubject最常用的使用场景就是用来代替代理，接下来我们写一个小的需求来看一下是如何实现的代替代理。目前，我们有这样一个需求:

给当前控制器添加一个按钮，modal到另一个控制器界面
另一个控制器view中有个按钮，点击按钮，通知当前控制器
我们用RACSubject可以这样来实现:

 
    @interface TwoViewController : UIViewController
    
    @property (nonatomic, strong) RACSubject *delegateSignal;
    
    @end
    

    @implementation TwoViewController
    - (IBAction)notice:(id)sender {
        // 通知第一个控制器，告诉它，按钮被点了
        
        // 通知代理
        // 判断代理信号是否有值
        if (self.delegateSignal) {
            // 有值，才需要通知
            [self.delegateSignal sendNext:nil];
        }
    }
    @end
    
    @implementation OneViewController
    - (IBAction)btnClick:(id)sender {
        
        // 创建第二个控制器
        TwoViewController *twoVc = [[TwoViewController alloc] init];
        
        // 设置代理信号
        twoVc.delegateSignal = [RACSubject subject];
        
        // 订阅代理信号
        [twoVc.delegateSignal subscribeNext:^(id x) {
            
            NSLog(@"点击了通知按钮");
        }];
        
        // 跳转到第二个控制器
        [self presentViewController:twoVc animated:YES completion:nil];
        
    }
    @end

在上述代码中，大致分为三个步骤:

在第二个控制器.h，添加一个RACSubject代替代理
监听第二个控制器按钮点击
在第一个控制器中，监听跳转按钮，给第二个控制器的代理信号赋值，并且监听
你看，用RACSubject代替代理就是这么简单滴就实现啦。

3. RACReplaySubject简单介绍以及应用

既然讲到了RACSubject，那么久一起把它的子类RACReplaySubject顺便说了吧... RACReplaySubject是重复提供信号类，它的使用场景一般有以下两个:

如果一个信号每被订阅一次，就需要把之前的值重复发送一遍，使用重复提供信号类
可以设置 capacity 数量来限制缓存的 value 的数量,即只缓充最新的几个值
RACReplaySubject的创建方法也很简单明了，首先创建RACReplaySubject，然后订阅信号，最后发送信号。而它的工作流程可以大致分为以下的三步：

订阅信号时，内部保存了订阅者，和订阅者响应block
当发送信号时，遍历订阅者，调用订阅者的nextBlock
发送的信号会保存起来，当订阅者订阅信号时，会将之前保存的信号，一个一个遍历
最后，我们通过简单的小例子来看一下它的使用：

    RACReplaySubject *replaySubject = [RACReplaySubject subject];
    [replaySubject subscribeNext:^(id x) {
        NSLog(@"1 %@,type:%@",x,NSStringFromClass(object_getClass(x)));
    }];
    [replaySubject subscribeNext:^(id x) {
        NSLog(@"1 %@,type:%@",x,NSStringFromClass(object_getClass(x)));
    }];
    [replaySubject sendNext:@1];
    
    [replaySubject subscribeNext:^(id x) {
        NSLog(@"3 %@,type:%@",x,NSStringFromClass(object_getClass(x)));
    }];

    //输出
//    1 1,type:__NSCFNumber
//    1 1,type:__NSCFNumber
//    3 1,type:__NSCFNumber

通过上面的代码，我们可以看出RACReplaySubject与RACSubject的区别，RACSubject必须要先订阅信号之后才能发送信号，而RACReplaySubject可以先发送信号后订阅。

四. RACSequence以及RACTuple的基本简介跟使用

啊哈哈，在本章节我们将隆重的介绍RACSequence，它是RAC中的集合类，可以用于代替NSArray,NSDictionary,可以使用它来快速遍历数组和字典。我们就对数组的操作简单的总结一下它的流程:

把数组转换成集合RACSequence numbers.rac_sequence
把集合RACSequence转换RACSignal信号类 numbers.rac_sequence.signal
订阅信号，激活信号，会自动把集合中的所有值，遍历出来

    NSArray *arr = @[@1,@2,@3,@4,@5,@6];
    [arr.rac_sequence.signal subscribeNext:^(id x) {
        
        NSLog(@"当前的值x:%@",x);
    }];
    //输出
//    当前的值x:1
//    当前的值x:2
//    当前的值x:3
//    当前的值x:4
//    当前的值x:5
//    当前的值x:6
    
    
    NSDictionary *dict = [NSDictionary dictionaryWithObjectsAndKeys:@"jtd",@"name",@"man",@"sex",@"jx",@"jg", nil];
    [dict.rac_sequence.signal subscribeNext:^(id x) {
        RACTupleUnpack(NSString *key,NSString *value) = x;
        
        NSLog(@"key:%@,value:%@",key,value);
    }];
    //输出：
//    key:name,value:jtd
//    key:sex,value:man
//    key:jg,value:jx

如以上代码所示，就如此方便快捷的实现了对数组以及字典的遍历操作。同样的也可以对转化之后的数组进行诸如map,filter,reduce,skip,take,contact..等等操作，接下来，我们通过代码来详细看一下:

    NSArray *array=@[@(2),@(5),@(7),@(15)];
    RACSequence *sequence = [array rac_sequence];
    
    id mapData = [sequence map:^id(id value) {
        return @([value integerValue] * 2);
    }];
    NSLog(@"序列Map之后的数据:%@",[mapData array]);
    
    id filterData = [sequence filter:^BOOL(id value) {
        return [value integerValue]%2 == 0;
    }];
    NSLog(@"序列Filter之后的数据:%@",[filterData array]);
    
    id reduceData = [sequence foldLeftWithStart:@"" reduce:^id(id accumulator, id value) {
        return [accumulator stringByAppendingString:[value stringValue]];
    }];
    NSLog(@"序列Left-Reduce之后的数据:%@",reduceData);
    
    id rightReduceData = [sequence foldRightWithStart:@"" reduce:^id(id first, RACSequence *rest) {
        return [NSString stringWithFormat:@"%@%@", rest.head, first];
    }];
    NSLog(@"序列Right-Reduce之后的数据:%@",rightReduceData);
    
    id skipData = [sequence skip:1];
    NSLog(@"序列Skip之后的数据:%@",[skipData array]);
    
    
    id takeData = [sequence take:2];
    NSLog(@"序列Take之后的数据:%@",[takeData array]);
    
    id takeUntilData = [sequence takeUntilBlock:^BOOL(id x) {
        return [x integerValue] == 7;
    }];
    NSLog(@"序列TakeUntil之后的数据:%@",[takeUntilData array]);
    
    NSArray *nextArr = @[@"A",@"B",@"C"];
    RACSequence *nextSequence = [nextArr rac_sequence];
    id contactData = [sequence concat:nextSequence];
    NSLog(@"FlyElephant序列Contact之后的数据:%@",[contactData array]);

    //输出
//    序列Map之后的数据:(
//                                           4,
//                                           10,
//                                           14,
//                                           30
//                                           )
//    序列Filter之后的数据:(
//                                                                      2
//                                                                      )
//    序列Left-Reduce之后的数据:25715
//    序列Right-Reduce之后的数据:15752
//    序列Skip之后的数据:(
//                                                                    5,
//                                                                    7,
//                                                                    15
//                                                                    )
//    序列Take之后的数据:(
//                                                                    2,
//                                                                    5
//                                                                    )
//    序列TakeUntil之后的数据:(
//                                                                         2,
//                                                                         5
//                                                                         )
//    FlyElephant序列Contact之后的数据:(
//                                                                                  2,
//                                                                                  5,
//                                                                                  7,
//                                                                                  15,
//                                                                                  A,
//                                                                                  B,
//                                                                                  C
//                                                                                  )

然后，我们再来看一下RACTuple这个类，RACTuple是ReactiveCocoa的元组类，首先上图看一下他的定义。

@interface RACTuple : NSObject 

@property (nonatomic, readonly) NSUInteger count;

@property (nonatomic, readonly) id first;
@property (nonatomic, readonly) id second;
@property (nonatomic, readonly) id third;
@property (nonatomic, readonly) id fourth;
@property (nonatomic, readonly) id fifth;
@property (nonatomic, readonly) id last;
@property (nonatomic, strong) NSArray *backingArray;

@property (nonatomic, copy, readonly) RACSequence *rac_sequence; // 这个是专门为sequence提供的一个扩展

@end

可以看到，RACTuple的定义看上去很简单，底层实质就是一个NSArray，只不过封装了一些方法。RACTuple继承了NSCoding, NSCopying, NSFastEnumeration这三个协议，具体的协议就不做过多的解读了，本文本着 "如何使用" 来进行基础讲解，况且RACTuple的方法也不多，总共就6个方法，3个类方法，3个实例方法。RACTuple有如下的优点:

可用下标访问元素（实现了objectAtIndexedSubscript:方法）
可用for in枚举（遵循NSFastEnumeration协议）
可跟NSArray互相转换
可转换为RACSequence
可把NSNull.null转为RACTupleNil.tupleNil
我们通过简单的实例来看一下用法，请看如下代码:

    //普通创建
    RACTuple *tuple1 = [RACTuple tupleWithObjects:@1, @2, @3, nil];
    RACTuple *tuple2 = [RACTuple tupleWithObjectsFromArray:@[@1, @2, @3]];
    RACTuple *tuple3 = [[RACTuple alloc] init];
    
    //宏创建
    RACTuple *tuple4 = RACTuplePack(@1, @2, @3, @4);
    
    //解包(等号前面是参数定义，后面是已存在的Tuple，参数个数需要跟Tuple元素相同）
    RACTupleUnpack(NSNumber * value1, NSNumber * value2, NSNumber * value3, NSNumber * value4) = tuple4;
    NSLog(@"%@ %@ %@ %@", value1, value2, value3, value4);
    
    //元素访问方式
    NSLog(@"%@", [tuple4 objectAtIndex:1]);
    NSLog(@"%@", tuple4[1]);
    
    //输出
    //1 2 3 4
    //2
    //2

好了，今天的文章就到此吧，接下来的文章，我们将要探讨一下RACCommand以及简单的UIKit的实际运用，下篇文章见。