ReactiveCocoa从基础到进阶(一)

本文中涉及到的工程代码demo。

1.ReactiveCocoa简介

ReactiveCocoa（简称为RAC）,是由Github开源的一个应用于iOS和OS开发的新框架,Cocoa是苹果整套框架的简称，因此很多苹果框架喜欢以Cocoa结尾。

Preview.jpg

2.ReactiveCocoa作用

• 在我们iOS开发过程中，当某些事件响应的时候，需要处理某些业务逻辑,这些事件都用不同的方式来处理。
• 比如按钮的点击使用action，ScrollView滚动使用delegate，属性值改变使用KVO等系统提供的方式。
• 其实这些事件，都可以通过RAC处理
• ReactiveCocoa为事件提供了很多处理方法，而且利用RAC处理事件很方便，可以把要处理的事情，和监听的事情的代码放在一起，这样非常方便我们管理，就不需要跳到对应的方法里。非常符合我们开发中高聚合，低耦合的思想。

3.ReactiveCocoa编程思想

ReactiveCocoa结合了几种编程风格：
函数式编程（Functional Programming）
响应式编程（Reactive Programming）
所以，你可能听说过ReactiveCocoa被描述为函数响应式编程（FRP）框架。

以后使用RAC解决问题，就不需要考虑调用顺序，直接考虑结果，把每一次操作都写成一系列嵌套的方法中，使代码高聚合，方便管理。

4.如何导入ReactiveCocoa框架

ReactiveCocoa 框架根据开发的语言不通分为以下几种：

• ReactiveObjc : 使用 Objective-C 开发
• ReactiveSwift ：使用 Swift 语言开发
• ReactiveObjcBridge：使用两种语言混和开发

所以在导入的时候也要进行区分：

ReactiveObjc.png
ReactiveSwift.png
ReactiveObjcBridge.png

5.ReactiveCocoa常见类

学习框架首要之处:先要搞清楚框架中常用的类，在 RAC 中最核心的类 RACSiganl 。

5.1)--> RACSiganl : 信号类,一般表示将来有数据传递，只要有数据改变，信号内部接收到数据，就会马上发出数据。

tips:

• 信号类(RACSiganl)，只是表示当数据改变时，信号内部会发出数据，它本身不具备发送的能力，而是交给内部一个订阅者去发出。

• 默认一个信号都是冷信号，也就是值改变了，也不会触发，只有订阅了这个信号，这个信号才会变为热信号，值改变了才会触发。

• 如何订阅信号：一部操作：调用信号的 subscribeNext 就能完成订阅。

RACSiganl 简单使用:

// 1. 创建信号
    RACSignal *signal = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        
        NSLog(@"Entry moment 1");
        
        // 3. 发送信号
        [subscriber sendNext:@"This is Signal content"];
        
        NSLog(@"Entry moment 2");
        
        // 4. 信号发送完成之后，最好调用下面的完成方法。
        [subscriber sendCompleted];
        
        // 5. 调用了上述的完成方法以后，内部会自动调用[RACDisposable disposable]取消订阅信号，返回一个 RACDisposable 对象
        return [RACDisposable disposableWithBlock:^{
            
            // block调用时刻：当信号发送完成或者发送错误，就会自动执行这个block,取消订阅信号。
            // 执行完Block后，当前信号就不在被订阅了。
            NSLog(@"Entry moment 3");
            
            NSLog(@"信号被销毁");
            
        }];
    }];
    
    //2. 订阅信号
    [signal subscribeNext:^(id  _Nullable x) {
        
        NSLog(@"Entry moment 4");
        NSLog(@"信号的内容：%@",x);
        
    }];


// 可以将以上步骤合并如下：
    [[RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        
        // 3. 发送信号
        [subscriber sendNext:@"This is Signal content"];
        [subscriber sendCompleted];
        
        return [RACDisposable disposableWithBlock:^{
            
        }];
        
    }]subscribeNext:^(id  _Nullable x) {
        
        NSLog(@"信号的内容：%@",x);
        
    }];

• 使用 NSLog(@"Entry moment %ld") 查看执行顺序
• 执行结果如下：

16:12:47.257815+0800 ReactiveCocoa_01[38834:19057824] Entry moment 1
16:12:47.257953+0800 ReactiveCocoa_01[38834:19057824] Entry moment 4
16:12:47.258050+0800 ReactiveCocoa_01[38834:19057824] 信号的内容：This is Signal content
16:12:47.258121+0800 ReactiveCocoa_01[38834:19057824] Entry moment 2
16:12:47.258229+0800 ReactiveCocoa_01[38834:19057824] Entry moment 3
16:12:47.258307+0800 ReactiveCocoa_01[38834:19057824] 信号被销毁

• RACSignal 底层实现：
  1. 创建信号，首先把 didSubscribe block 保存到信号中，等待合适时机被触发
  2. 当信号被订阅，调用 subscribeNext:nextBlock 方法（ nextBlock 就是订阅者在接收到消息以后要干的事情 ）。在该方法内部就会创建一个订阅者subscriber，并且把 nextBlock 保存到 subscriber 中，完成订阅。同时将订阅者 subscriber 作为参数调用信号的 didSubscribe
  3. 在 didSubscribe 内部给订阅者发送消息，调用 [subscriber sendNext:@" "]
  4. sendNext 底层其实就是执行 subscriber 的 nextBlock

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

5.3)--> RACDisposable: 用于取消订阅或者清理资源，当信号发送完成或者发送错误的时候，就会自动触发它。

5.4)--> RACSubject: 信号提供者，自己可以充当信号，又能发送信号。通常用来代替代理，有了它，就不必要定义代理了。RACSubject 替换代理的使用举例demo。

提到 RACSuject 信号就不得不提 冷信号 和 热信号 ：

• 冷信号是被动的，只会在被订阅时向订阅者发送通知；
• 热信号是主动的，它会在任意时间发出通知，与订阅者的订阅时间无关。

在 ReactiveCocoa 中，我们使用 RACSignal 来表示冷信号，也就是每一个订阅者在订阅信号时都会收到完整的序列；RACSubject 用于表示热信号，订阅者接收到多少值取决于它订阅的时间。

举个恰当的例子：

热信号在我们生活中有很多的例子，比如订阅杂志时并不会把之前所有的期刊都送到我们手中，只会接收到订阅之后的期刊；而对于冷信号的话，举一个不恰当的例子，每一年的高考考生在『订阅』高考之后，收到往年所有的试卷，并在高考之后会取消订阅。

用代码说明一下：

• 冷信号

RACSignal *signal = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        
        [subscriber sendNext:@"This is Signal content"];
        
        [subscriber sendCompleted];
        return [RACDisposable disposableWithBlock:^{
            
        }];
        
    }];
    
    //2. 订阅信号
    [signal subscribeNext:^(id  _Nullable x) {
        NSLog(@"subscriber 1  : %@",x);
    }];
    
    [signal subscribeNext:^(id  _Nullable x) {
        NSLog(@"subscriber 2  : %@",x);
    }];
    
    [signal subscribeNext:^(id  _Nullable x) {
        NSLog(@"subscriber 3  : %@",x);
    }];

结果如下：

17:31:23.168495+0800 ReactiveCocoa_01[39438:19287551] subscriber 1  : This is Signal content
17:31:23.168737+0800 ReactiveCocoa_01[39438:19287551] subscriber 2  : This is Signal content
17:31:23.168859+0800 ReactiveCocoa_01[39438:19287551] subscriber 3  : This is Signal content

• 热信号

// RACSubject
    RACSubject *subject = [RACSubject subject];
    
    // Subscriber 1
    [subject subscribeNext:^(id  _Nullable x) {
        NSLog(@"subscriber 1  : %@",x);
    }];
    [subject sendNext:@"this is a message 1"];
    
    // Subscriber 2： 之前 Subscriber 1 发送的消息收不到 ，只能收到以后的消息
    [subject subscribeNext:^(id  _Nullable x) {
        NSLog(@"subscriber 2  : %@",x);
    }];
    [subject sendNext:@"this is a message 2"];
    
    // Subscriber 3：之前 Subscriber 1、Subscriber 2 发送的消息都收不到，只能收到以后的消息
    [subject subscribeNext:^(id  _Nullable x) {
        NSLog(@"subscriber 3  : %@",x);
    }];
    [subject sendNext:@"this is a message 3"];
    
    [subject sendCompleted];

结果如下：

17:31:23.169021+0800 ReactiveCocoa_01[39438:19287551] subscriber 1  : this is a message 1

17:31:23.169142+0800 ReactiveCocoa_01[39438:19287551] subscriber 1  : this is a message 2
17:31:23.169212+0800 ReactiveCocoa_01[39438:19287551] subscriber 2  : this is a message 2

17:31:23.169306+0800 ReactiveCocoa_01[39438:19287551] subscriber 1  : this is a message 3
17:31:23.169372+0800 ReactiveCocoa_01[39438:19287551] subscriber 2  : this is a message 3
17:31:23.169438+0800 ReactiveCocoa_01[39438:19287551] subscriber 3  : this is a message 3

5.5)--> RACReplaySubject: 重复提供信号类，RACSubject 的子类。它与 RACSubject 有啥区别呢？RACReplaySubject 可以先发送信号，再订阅信号，RACSubject 就不可以。

使用场景：

• 如果一个信号每被订阅一次，就需要把之前的值重复发送一遍，使用重复提供信号类。

• 可以设置capacity数量来限制缓存的value的数量,即只缓充最新的几个值。

RACSubject 和 RACReplaySubject 简单使用:

// RACSubject
    RACSubject *subject = [RACSubject subject];
    [subject subscribeNext:^(id  _Nullable x) {
        NSLog(@"the first subscriber got %@",x);
    }];
    [subject subscribeNext:^(id  _Nullable x) {
        NSLog(@"the second subscriber got %@",x);
    }];
    [subject sendNext:@"222"];
    [subject sendCompleted];
    ------------------------------------------------------------------
    // RACReplaySubject
    RACReplaySubject *replaySubject = [RACReplaySubject subject];
    [replaySubject sendNext:@"666"];
    [replaySubject sendNext:@"888"];
    [replaySubject subscribeNext:^(id  _Nullable x) {
        NSLog(@"the first subscriber got %@",x);
    }];
    [replaySubject subscribeNext:^(id  _Nullable x) {
        NSLog(@"the second subscriber got %@",x);
    }];

输出结果如下：

11:15:32.055002+0800 ReactiveCocoa_01[45917:19698401] the first subscriber got 222
11:15:32.055128+0800 ReactiveCocoa_01[45917:19698401] the second subscriber got 222

11:15:32.056002+0800 ReactiveCocoa_01[45917:19698401] the first subscriber got 666
11:15:32.056109+0800 ReactiveCocoa_01[45917:19698401] the first subscriber got 888

11:15:32.056206+0800 ReactiveCocoa_01[45917:19698401] the second subscriber got 666
11:15:32.056289+0800 ReactiveCocoa_01[45917:19698401] the second subscriber got 888

几点说明：

RACSubject：

• 1.调用subscribeNext订阅信号，只是把订阅者保存起来，并且订阅者的nextBlock已经赋值了
• 2.调用sendNext发送信号，遍历刚刚保存的所有订阅者，一个一个调用订阅者的nextBloc

RACReplaySubject：

• 1.调用sendNext发送信号，把值保存起来
• 2.调用subscribeNext订阅信号，遍历保存的所有值，一个一个调用订阅者的nextBlock
• 3.如果想当一个信号被订阅，就重复播放之前所有值，需要先发送信号，再订阅信号

5.6)--> RACTuple: 元组类,类似 NSArray , 用来包装值（常见包装字典键值对）
5.7)--> RACSequence: RAC 中的集合类，用于代替 NSArray,NSDictionary, 可以使用它来快速遍历数组和字典。

常见用法：

• 遍历数组

// 1.遍历数组
    NSArray *numbers = @[@"A",@"B",@"C",@"D"];
    // 这里其实是三步
    // 第一步: 把数组转换成集合RACSequence numbers.rac_sequence
    // 第二步: 把集合RACSequence转换RACSignal信号类,numbers.rac_sequence.signal
    // 第三步: 订阅信号，激活信号，会自动把集合中的所有值，遍历出来。
    
    [numbers.rac_sequence.signal subscribeNext:^(id  _Nullable x) {
        NSLog(@"%@",x);
    }];
    
    // 2.遍历字典,遍历出来的键值对会包装成RACTuple(元组对象)
    NSDictionary *dict = @{@"name":@"dog",@"age":@2,@"address":@"一号大街"};
    [dict.rac_sequence.signal subscribeNext:^(id  _Nullable x) {
//        NSLog(@"%@",x);
        // 解包元组，会把元组的值，按顺序给参数里面的变量赋值
        RACTupleUnpack(NSString *key,NSString *value) = x;
        // 相当于以下写法
        //        NSString *key = x[0];
        //        NSString *value = x[1];
        
        NSLog(@"%@ %@",key,value);
    }];

结果如下：

14:33:11.513615+0800 ReactiveCocoa_01[48541:19892123] A
14:33:11.513769+0800 ReactiveCocoa_01[48541:19892123] B
14:33:11.513923+0800 ReactiveCocoa_01[48541:19892123] C
14:33:11.514128+0800 ReactiveCocoa_01[48541:19892123] D

14:33:11.514413+0800 ReactiveCocoa_01[48541:19892124] name dog
14:33:11.514678+0800 ReactiveCocoa_01[48541:19892124] age 2
14:33:11.514833+0800 ReactiveCocoa_01[48541:19892124] address 一号大街

• 字典转模型

    NSString *filePath = [[NSBundle mainBundle] pathForResource:@"flags.plist" ofType:nil];
    NSArray *dictArr = [NSArray arrayWithContentsOfFile:filePath];
    NSMutableArray *flags = [NSMutableArray array];
    _flags = flags;
    
    // rac_sequence注意点：调用subscribeNext，并不会马上执行nextBlock，而是会等一会

    [dictArr.rac_sequence.signal subscribeNext:^(id x) {
        // 运用RAC遍历字典，x：字典
        // 取出来的 x 是字典
        FlagItem *item = [FlagItem flagWithDict:x];
        
        [flags addObject:item];
        
    }];
------------------------------------------------------------------------------------------
// 也可以这么写：
NSString *filePath = [[NSBundle mainBundle] pathForResource:@"flags.plist" ofType:nil];
    
    NSArray *dictArr = [NSArray arrayWithContentsOfFile:filePath];
    // map:映射的意思，目的：把原始值value映射成一个新值
    // array: 把集合转换成数组
    // 底层实现：当信号被订阅，会遍历集合中的原始值，映射成新值，并且保存到新的数组里。
    NSArray *flags = [[dictArr.rac_sequence map:^id(id value) {
     
        return [FlagItem flagWithDict:value];
        
    }] array];

Tips :

• map 返回一个值 不是信号
• flattenMap 返回一个信号 和订阅信号一样

5.8)--> RACCommand: 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.创建信号 (声明强引用对象)
    self.command = [[RACCommand alloc]initWithSignalBlock:^RACSignal * _Nonnull(id  _Nullable input) {
        // input 参数
        NSLog(@"参数：%@",input);
        
        return [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
            //
            [subscriber sendNext:@"获取的数据"];
            //
            [subscriber sendCompleted];
            
            return [RACDisposable disposableWithBlock:^{
                NSLog(@"信号取消订阅");
            }];
        }];
        
    }];
    // 2.订阅RACCommand中的信号
//    [self.command.executionSignals subscribeNext:^(id x) {
//
//        [x subscribeNext:^(id x) {
//
//            NSLog(@"%@",x);
//        }];
//
//    }];
    
    // RAC高级用法
    // switchToLatest:用于signal of signals，获取signal of signals发出的最新信号,也就是可以直接拿到RACCommand中的信号
    [self.command.executionSignals.switchToLatest subscribeNext:^(id x) {
        
        NSLog(@"%@",x);
    }];
    
    // 3.监听命令是否执行完毕,默认会来一次，可以直接跳过，skip表示跳过第一次信号。
    [[self.command.executing skip:1] subscribeNext:^(id x) {
        
        if ([x boolValue] == YES) {
            // 正在执行
            NSLog(@"正在执行");
            
        }else{
            // 执行完成
            NSLog(@"执行完成");
        }
        
    }];
    // 4.执行命令 传递参数
    [self.command execute:@"参数1"];

5.9)--> RACMulticastConnection: 用于当一个信号，被多次订阅时，为了保证创建信号时，避免多次调用创建信号中的block，造成副作用，可以使用这个类处理。

• 被多次调用的情形：

// 1.创建请求信号
    RACSignal *signal = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
        NSLog(@"发送请求");
        return nil;
    }];
    // 2.订阅信号
    [signal subscribeNext:^(id x) {
        NSLog(@"接收数据");
    }];
    // 2.订阅信号
    [signal subscribeNext:^(id x) {
        NSLog(@"接收数据");
    }];

结果：发现 每次订阅的时候，创建信号时候的 block 都调用了两次，这种情况不是我们想要的

16:08:37.952739+0800 ReactiveCocoa_01[49203:20067521] 发送请求
16:08:37.952878+0800 ReactiveCocoa_01[49203:20067521] 发送请求

以上信号在订阅的时候就激活了，接下来想办法怎么阻止在订阅的时候激活 ?

• 解决方案

    // RACMulticastConnection:解决重复请求问题
    // 1.创建信号
    RACSignal *connectionSignal = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
        
        
        NSLog(@"发送请求");
        [subscriber sendNext:@1];
        
        return nil;
    }];
    
    // 创建连接
    RACMulticastConnection *connection = [connectionSignal publish];
    // 订阅信号 ,这里订阅信号 也不能激活信号，只是将信号保存到数组中
    [connection.signal subscribeNext:^(id  _Nullable x) {
        NSLog(@"订阅者1");
    }];
    [connection.signal subscribeNext:^(id  _Nullable x) {
        NSLog(@"订阅者2");
    }];
    
    // 激活信号
    [connection connect];

结果如下：

16:25:41.081161+0800 ReactiveCocoa_01[49363:20103345] connection  发送请求
16:25:41.081269+0800 ReactiveCocoa_01[49363:20103345] connection  订阅者1
16:25:41.081356+0800 ReactiveCocoa_01[49363:20103345] connection  订阅者2

5.10)--> RACScheduler:RAC中的队列，用GCD封装的。

5.11)--> RACUnit :表⽰stream不包含有意义的值,也就是看到这个，可以直接理解为nil.

5.12)-->RACEvent: 把数据包装成信号事件(signal event)。它主要通过RACSignal的-materialize来使用，然并卵。

6.ReactiveCocoa开发中常见用法

6.1 替代代理
rac_signalForSelector：用于替代代理

    // 需求：自定义redView,监听红色view中按钮点击
    // 之前都是需要通过代理监听，给红色View添加一个代理属性，点击按钮的时候，通知代理做事情
    // rac_signalForSelector:把调用某个对象的方法的信息转换成信号，就要调用这个方法，就会发送信号。
    // 这里表示只要redV调用btnClick:,就会发出信号，订阅就好了。
    [[redV rac_signalForSelector:@selector(btnClick:)] subscribeNext:^(id x) {
        NSLog(@"点击红色按钮");
    }];

6.2 代替KVO :
rac_valuesAndChangesForKeyPath：用于监听某个对象的属性改变。

// 2.KVO
    // 把监听redV的center属性改变转换成信号，只要值改变就会发送信号
    // observer:可以传入nil
    [[redV rac_valuesAndChangesForKeyPath:@"center" options:NSKeyValueObservingOptionNew observer:nil] subscribeNext:^(id x) {

        NSLog(@"%@",x);

    }];

6.3 监听事件:
rac_signalForControlEvents：用于监听某个事件。

// 把按钮点击事件转换为信号，点击按钮，就会发送信号
    [[self.btn rac_signalForControlEvents:UIControlEventTouchUpInside] subscribeNext:^(id x) {

        NSLog(@"按钮被点击了");
    }];

6.4 代替通知:
rac_addObserverForName:用于监听某个通知。

// 把监听到的通知转换信号
    [[[NSNotificationCenter defaultCenter] rac_addObserverForName:UIKeyboardWillShowNotification object:nil] subscribeNext:^(id x) {
        NSLog(@"键盘弹出");
    }];

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

// 5.监听文本框的文字改变
   [_textField.rac_textSignal subscribeNext:^(id x) {

       NSLog(@"文字改变了%@",x);
   }];

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

rac_liftSelector:withSignalsFromArray:Signals:当传入的Signals(信号数组)，每一个signal都至少sendNext过一次，就会去触发第一个selector参数的方法。
使用注意：几个信号，参数一的方法就几个参数，每个参数对应信号发出的数据。

RACSignal *request1 = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
        
        // 发送请求1
        [subscriber sendNext:@"发送请求1"];
        return nil;
    }];
    
    RACSignal *request2 = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
        // 发送请求2
        [subscriber sendNext:@"发送请求2"];
        return nil;
    }];
    
    // 使用注意：几个信号，参数一的方法就几个参数，每个参数对应信号发出的数据。
    [self rac_liftSelector:@selector(updateUIWithR1:r2:) withSignalsFromArray:@[request1,request2]];

// 更新UI
- (void)updateUIWithR1:(id)data r2:(id)data1
{
    NSLog(@"更新UI%@  %@",data,data1);
}

7. ReactiveCocoa常见宏

7.1 RAC(TARGET, [KEYPATH, [NIL_VALUE]]):用于给某个对象的某个属性绑定。

// 只要文本框文字改变，就会修改label的文字
    RAC(self.labelView,text) = _textField.rac_textSignal;

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

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

7.3 @weakify(Obj)和@strongify(Obj),一般两个都是配套使用,在主头文件(ReactiveCocoa.h)中并没有导入，需要自己手动导入，RACEXTScope.h 才可以使用。但是每次导入都非常麻烦，只需要在主头文件自己导入就好了。

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

// 把参数中的数据包装成元组
    RACTuple *tuple = RACTuplePack(@10,@20);

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

// 把参数中的数据包装成元组
    RACTuple *tuple = RACTuplePack(@"xmg",@20);
    
    // 解包元组，会把元组的值，按顺序给参数里面的变量赋值
    // name = @"xmg" age = @20
    RACTupleUnpack(NSString *name,NSNumber *age) = tuple;