由于近期时间相对宽裕，以及很多朋友询问关于RAC的学习路径以及资料，故而整理一下之前自己学习RAC的学习笔记，供大家查阅练习。该文章只讲解了RAC的详细用法，有关其内部原理以及实现，请参考ReactiveCocoa深入理解 。

一. ReactiveCocoa简介

1.解决的问题

作为一个iOS开发者，你写的每一行代码几乎都是在相应某个事件，例如按钮的点击，收到网络消息，属性的变化（通过KVO）或者用户位置的变化（通过CoreLocation）。但是这些事件都用不同的方式来处理，比如action、delegate、KVO、callback等。ReactiveCocoa为事件定义了一个标准接口，从而可以使用一些基本工具来更容易的连接、过滤和组合。

2.编程思想

ReactiveCocoa结合了几种编程风格：

• 函数式编程（Functional Programming）

• 响应式编程（Reactive Programming）

所以，你可能听说过ReactiveCocoa被描述为函数响应式编程（FRP）框架。以后使用RAC解决问题，就不需要考虑调用顺序，直接考虑结果，把每一次操作都写成一系列嵌套的方法中，使代码高聚合，方便管理。

3.常见的五个宏

• RAC(TARGET, [KEYPATH, [NIL_VALUE]])

作用: 用于给某个对象的某个属性绑定

实例: 只要文本框的文字改变，就会修改label的文字

RAC(self.labelView,text) = _textField.rac_textSignal;

• RACObserve(self, name)

作用: 监听某个对象的某个属性，返回的是信号

实例: 监听self.view的center变化

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

注意事项: 当RACObserve放在block里面使用时一定要加上weakify，不管里面有没有使用到self；否则会内存泄漏，因为RACObserve宏里面就有一个self。

@weakify(self);
RACSignal *signal3 = [anotherSignal flattenMap:^(NSArrayController *arrayController) {
   Avoids a retain cycle because of RACObserve implicitly referencing self
  @strongify(self);
  return RACObserve(arrayController, items);
}];

• @weakify(Obj)和@strongify(Obj)

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

• RACTuplePack

作用: 把数据包装成RACTuple（元组类）

实例: 把参数中的数据包装成元组

RACTuple *tuple = RACTuplePack(@10,@20);

• RACTupleUnpack

作用: 把RACTuple（元组类）解包成对应的数据

实例: 把参数中的数据包装成元组

RACTuple *tuple = RACTuplePack(@"xmg",@20);

注意事项: 解包元组，会把元组的值，按顺序给参数里面的变量赋值

二. RACSignal基础知识点

1.信号类(RACSignal) 简介

信号类(RACSiganl)，只是表示当数据改变时，信号内部会发出数据，它本身不具备发送信号的能力，而是交给内部一个订阅者去发出.默认一个信号都是冷信号，也就是值改变了，也不会触发，只有订阅了这个信号，这个信号才会变为热信号，值改变了才会触发。

如何订阅信号?

调用信号RACSignal的subscribeNext就能订阅

2.信号类(RACSignal)实践

1. RACSignal的简单使用

完整的创建RACSignal 包含三部分sendError（不一定要有） sendNext（可多个） sendCompleted(不一定要有)。 下面代码中的RACSubscriber表示订阅者的意思，用于发送信号，这是一个协议，不是一个类，只要遵守这个协议，并且实现方法才能成为订阅者。通过create创建的信号，都有一个订阅者，帮助他发送数据。

 RACSignal *signal=[RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
        @strongify(self)
        NSError *error;
        if ([self.curTag isEqualToString:@"error"]) {
            error=[[NSError alloc]initWithDomain:@"myError" code:2001 userInfo:nil];
            [subscriber sendError:error];
        }
        else
        {
            [subscriber sendNext:@"1"];
            [subscriber sendNext:@"3"];
            [subscriber sendNext:@"5"];
            [subscriber sendCompleted];
        }
        return [RACDisposable disposableWithBlock:^{
            NSLog(@"执行清理");
            //RACDisposable:用于取消订阅或者清理资源，当信号发送完成或者发送错误的时候，就会自动触发它
            //使用场景:不想监听某个信号时，可以通过它主动取消订阅信号
        }];
    }];
    
    [signal subscribeNext:^(id x) {
        NSLog(@"当前的值为：%@",x);
    }];
    
    [signal subscribeError:^(NSError *error) {
        NSLog(@"当前出现错误%@",error);
    }];
    
    [signal subscribeNext:^(id x) {
        NSLog(@"2当前的值为：%@",x);
    }];

以上代码的输出为：

    执行清理
    当前出现错误Error Domain=myError Code=2001 "(null)"
    执行清理
    执行清理

2. filter、map以及flattenMap的使用

首先我们创建简单的signal对象，然后通过该对象对filter、map以及flattenMap进行讲解。

 RACSignal *signal=[RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
        [subscriber sendNext:@"1"];
        [subscriber sendNext:@"3"];
        [subscriber sendNext:@"15"];
        [subscriber sendNext:@"wujy"];
        [subscriber sendCompleted];
        return [RACDisposable disposableWithBlock:^{
            NSLog(@"执行清理");
        }];
    }];

然后，我们看一下filter的作用，filter顾名思义就是过滤的意思，我们来看以下代码:

 [[signal filter:^BOOL(id value) {
        if ([value isEqualToString:@"wujy"]) {
            return YES;
        }
        return NO;
    }] subscribeNext:^(id x) {
        NSLog(@"当前的值为：%@",x);
    }];
//输出为: 当前的值为：wujy  执行清理

以上的代码逻辑中，对signal进行过滤，只有传入的字符串为“wujy”，才发送信号。

接下来，我们看一下先filter过滤后又用map进行转换的效果，请看以下代码:

[[[signal filter:^BOOL(id value) {
        if ([value isEqualToString:@"wujy"]) {
            return NO;
        }
        return YES;
    }] map:^id(NSString *value) {
        return @(value.length);
    }] subscribeNext:^(NSNumber *x) {
        NSLog(@"当前的位数为：%zd",[x integerValue]);
    }];
//输出为: 当前的位数为:1  
         当前的位数为:1     
         当前的位数为:2    
         执行清理

用map后原来的值就被转化，上述代码中，将value的值转化成了长度。

接下来，我们再看一下flattenMap的使用效果，代码如下:

 [[signal flattenMap:^RACStream *(id value) {
        return [RACSignal return:[NSString stringWithFormat:@"当前输出为：%@",value]];
    }] subscribeNext:^(id x) {
        NSLog(@"flattenMap中执行：%@",x);
    }];
flattenMap的作用是 根据前一个信号的参数创建一个新的信号，以上代码的输出为:  
flattenMap中执行：当前输出为：1
flattenMap中执行：当前输出为：3
flattenMap中执行：当前输出为：15
flattenMap中执行：当前输出为：wujy

那么map跟flattenMap有什么区别呢？

1. FlatternMap中的Block返回信号
2. Map中的Block返回对象
3. 如果信号发出的值不是信号，映射一般使用Map
4. 如果信号发出的值是信号，映射一般使用FlatternMap

3. ignore、ignoreValues、take、takeUntilBlock以及takeLast的使用

之后，我们再继续介绍RAC的其他基本知识点，同样的方式，我们通过代码的方式呈现。
首先，看一下ignore的使用，该用法相对简单，我就直接上代码了。

 //ignore 忽略某个值
    [[signal ignore:@"3"] subscribeNext:^(id x) {
        NSLog(@"当前的值为：%@",x);
    }];
    //输出：当前的值为：1  当前的值为：15  当前的值为：wujy   执行清理

接下来，我们看一下ignoreValues的使用效果，ignoreValues 这个比较极端，忽略所有值，只关心Signal结束，也就是只取Comletion和Error两个消息，中间所有值都丢弃。

[[signal ignoreValues] subscribeNext:^(id x) {
        //它是没机会执行  因为ignoreValues已经忽略所有的next值
        NSLog(@"ignoreValues当前值：%@",x);
    } error:^(NSError *error) {
        NSLog(@"ignoreValues error");
    } completed:^{
        NSLog(@"ignoreValues completed");
    }];
//    输出
//    ignoreValues completed

然后，我们看一下take的相关用法。首先，我们先登场的是take的简单使用，take的意思是：从开始一共取N次的信号。

[[signal take:1] subscribeNext:^(id x) {
        NSLog(@"take 获取的值：%@",x);
    }];
    //输出：take 获取的值：1

用法相对简单，不做过多介绍，我们马上来看一下takeUntilBlock的用法，takeUntilBlock的意思是:对于每个next值，运行block，当block返回YES时停止取值

 [[signal takeUntilBlock:^BOOL(NSString *x) {
        if ([x isEqualToString:@"15"]) {
            return YES;
        }
        return NO;
    }] subscribeNext:^(id x) {
        NSLog(@"takeUntilBlock 获取的值：%@",x);
    }];
//    输出
//    takeUntilBlock 获取的值：1
//    takeUntilBlock 获取的值：3

最后，我们看一下takeLast的使用，takeLast的意思是: 取最后N次的信号，但是它有一个前提条件，订阅者必须调用完成，因为只有完成，才知道总共有多少信号。

  [[signal takeLast:1] subscribeNext:^(id x) {
        NSLog(@"takeLast 获取的值：%@",x);
    }];
    //输出：takeLast 获取的值：wujy

4. skip、skipUntilBlock、skipWhileBlock、startWith以及reduceEach的使用

RAC的基础知识真是众多且难记，喝杯小茶，我们接着来。啦啦啦，我们再看一下关于剩余的知识点。首先，skip登场，skip的字面意思即跳跃，他的使用就是跳过几个信号,不接受。skipUntilBlock的意思类似，skipUntilBlock是一直跳，直到block为YES。

//skip
[[signal skip:2] subscribeNext:^(id x) {
        NSLog(@"skip 获取的值：%@",x);
    }];
    //输出：skip 获取的值：15    skip 获取的值：wujy

//skipUntilBlock
 [[signal skipUntilBlock:^BOOL(NSString *x) {
        if ([x isEqualToString:@"15"]) {
            return YES;
        }
        return NO;
    }] subscribeNext:^(id x) {
        NSLog(@"skipUntilBlock 获取的值：%@",x);
    }];
//    输出
//    skipUntilBlock 获取的值：15
//    skipUntilBlock 获取的值：wujy

skipWhileBlock跟skipUntilBlock是相反的意思，skipWhileBlock的意思是一直跳，直到block为NO

[[signal skipWhileBlock:^BOOL(NSString *x) {
        if ([x isEqualToString:@"15"]) {
            return NO;
        }
        return YES;
    }] subscribeNext:^(id x) {
        NSLog(@"skipWhileBlock 获取的值：%@",x);
    }];
//    输出
//    skipWhileBlock 获取的值：15
//    skipWhileBlock 获取的值：wujy

接下来，我们看一下startWith以及reduceEach的用法，startWith表示起始位置增加相应的元素，不要跟字符串的拼接混用，跟字符串的拼接还是有区别的。

 RACSignal *addStartSignal=[RACSignal return:@"123"];
    [[addStartSignal startWith:@"345"] subscribeNext:^(id x) {
        NSLog(@"startWith增加的值操作 %@",x);
    }];
//    输出
//    startWith增加的值操作 345
//    startWith增加的值操作 123

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

 RACSignal *aSignal=[RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
        [subscriber sendNext:RACTuplePack(@1,@4)];
        [subscriber sendNext:RACTuplePack(@2,@3)];
        [subscriber sendNext:RACTuplePack(@5,@2)];
        return nil;
    }];
    
    [[aSignal reduceEach:^id(NSNumber *first,NSNumber *secnod){
        return @([first integerValue]+[secnod integerValue]);
    }] subscribeNext:^(NSNumber *x) {
        NSLog(@"reduceEach当前的值：%zd",[x integerValue]);
    }];
//    输出
//    reduceEach当前的值：5
//    reduceEach当前的值：5
//    reduceEach当前的值：7

5. 关于时间以及流程相关的RAC语法操作

说到时间，首先想到的就是计时器的使用场景，在RAC中也有对应的计时器操作API，即: (RACSignal *)interval:(NSTimeInterval)interval onScheduler:(RACScheduler *)scheduler的用法。模仿定时器用，我们设置take方式，每隔段时间发出一个信号。

 [[[RACSignal interval:1 onScheduler:[RACScheduler mainThreadScheduler]] take:5]subscribeNext:^(id x) {
        NSLog(@"interval-take :吃药");
    }];
    //    输出(每隔一秒执行一句)
    //    interval-take :吃药
    //    interval-take :吃药
    //    interval-take :吃药
    //    interval-take :吃药
    //    interval-take :吃药

接下来，我们看一下有关超时的操作流程，请看以下代码:

 [[[RACSignal createSignal:^RACDisposable *(id subscriber) {
        [[[RACSignal createSignal:^RACDisposable *(id subscriber) {
            NSLog(@"我快到了");
            [subscriber sendNext:nil];
            [subscriber sendCompleted];
            return nil;
            //延迟2秒后执行next事件
        }] delay:2] subscribeNext:^(id x) {
            NSLog(@"我到了");
            [subscriber sendNext:nil];
            [subscriber sendCompleted];
        }];
        return nil;
    }] timeout:1 onScheduler:[RACScheduler mainThreadScheduler]] subscribeError:^(NSError *error) {
        NSLog(@"你再不来，我走了");
    }];
    
    //输出
    //我快到了
    //你再不来，我走了
    //我到了

在我们的实际开发中，有很多场景需要我们重新执行某个操作，比如网络请求中的再次刷新等，类似的场景我们就可以使用retry语法来实现。若发送的是error则可以使用retry来尝试重新刺激信号 retry重试 ：只要失败，就会重新执行创建信号中的block,直到成功.

 [[[RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
        
        NSLog(@"i = %d",i);
        if (i == 5) {
            [subscriber sendNext:@"i == 2"];
        }else{
            i ++;
            [subscriber sendError:nil];
        }
        return nil;
        //当发送的是error时可以retry重新执行
    }] retry] subscribeNext:^(id x) {
        NSLog(@"%@",x);
    }];
    
    //    输出：
    //    i = 0
    //    i = 1
    //    i = 2
    //    i = 3
    //    i = 4
    //    i = 5
    //    i == 2

还有一种我们常用的场景，即我们需要达到某个条件时，停止某些操作。如通知的注销，计时器的销毁等，我们可以使用takeUntil更加方便快捷的实现该需求。

    //创建一个信号
    [[[RACSignal createSignal:^RACDisposable *(id subscriber) {
        //创建一个定时信号，每隔1秒刺激一次信号
        [[RACSignal interval:1 onScheduler:[RACScheduler mainThreadScheduler]] subscribeNext:^(id x) {
            [subscriber sendNext:@"直到世界的尽头才能把我们分开"];
        }];
        return nil;
        //直到此情况下停止刺激信号
    }] takeUntil:[RACSignal createSignal:^RACDisposable *(id subscriber) {
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            NSLog(@"世界的尽头到了");
            [subscriber sendNext:@"世界的尽头到了"];
        });
        return nil;
    }]] subscribeNext:^(id x) {
        NSLog(@"%@", x);
    }];
    //输出：
    //    直到世界的尽头才能把我们分开
    //    直到世界的尽头才能把我们分开
    //    直到世界的尽头才能把我们分开
    //    世界的尽头到了

最后，再介绍一下doNext跟doCompleted以及throttle的使用，doNext: 执行Next之前，会先执行这个Block; doCompleted: 执行sendCompleted之前，会先执行这个Block。先看一下doNext跟doCompleted的使用:

[[[[RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
        [subscriber sendNext:@"执行sendNext"];
        NSLog(@"执行sendNext");
        [subscriber sendCompleted];
        return nil;
    }] doNext:^(id x) {
        NSLog(@"执行doNext");
    }] doCompleted:^{
        NSLog(@"执行doCompleted");
    }] subscribeNext:^(id x) {
        NSLog(@"执行subscribeNext");
    }];
    
//    输出
//    执行doNext
//    执行subscribeNext
//    执行sendNext
//    执行doCompleted

throttle是节流的意思，用来处理当某个信号发送比较频繁的情况。该情况下可以使用节流，在某一段时间不发送信号内容，过了一段时间获取信号的最新内容发出。

    RACSubject *throttleSignal = [RACSubject subject];
    [throttleSignal sendNext:@"throttle a"];
    // 节流，在一定时间（4秒）内，不接收任何信号内容，过了这个时间（1秒）获取最后发送的信号内容发出。
    [[throttleSignal throttle:4] subscribeNext:^(id x) {
        NSLog(@"throttleSignal:%@",x);
    }];
    
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"世界的尽头到了");
         [throttleSignal sendNext:@"throttle b"];
         [throttleSignal sendNext:@"throttle c"];
    });
    //输出：throttleSignal:throttle c

6. combineLatest、reduce、then、aggregateWithStart、scanWithStart的使用

在此之前，我们大多介绍的是基于单个信号的操作，接下来，我们讲解一下关于信号与信号之间的操作与处理问题。我们需要创建两个简单的信号，然后基于这两个信号，我们进行接下来的讲解工作。

 RACSignal *aSignal=[RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
        [subscriber sendNext:@"1"];
        [subscriber sendNext:@"3"];
        [subscriber sendCompleted];
        return [RACDisposable disposableWithBlock:^{
            NSLog(@"aSignal清理了");
        }];
    }];
    
    RACSignal *bSignal=[RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
        [subscriber sendNext:@"7"];
        [subscriber sendNext:@"9"];
        [subscriber sendCompleted];
        return [RACDisposable disposableWithBlock:^{
            NSLog(@"bSignal清理了");
        }];
    }];

首先，看一下combineLatest的用法，他的作用是将多个信号合并起来，并且拿到各个信号的最新的值， combineLatest有一个前提条件，即:必须每个合并的signal至少都有过一次sendNext，才会触发合并的信号。

    RACSignal *combineSignal = [aSignal combineLatestWith:bSignal];
    
    [combineSignal subscribeNext:^(id x) {
        
        NSLog(@"combineSignal为:%@",x);
    }];
    //输出
//    combineSignal为:<RACTuple: 0x600000015c30> (
//                                               3,
//                                               7
//                                               )
//    combineSignal为:<RACTuple: 0x600000015cb0> (
//                                                3,
//                                                9
//                                                                                                  )

combineLatest一般结合reduce聚合一起使用，将产生的最新的值聚合在一起，并生成一个新的信号。

 RACSignal *combineReduceSignal=[RACSignal combineLatest:@[aSignal,bSignal] reduce:^id(NSString *aItem,NSString *bItem){
        return [NSString stringWithFormat:@"%@-%@",aItem,bItem];
    }];
    
    [combineReduceSignal subscribeNext:^(id x) {
        NSLog(@"合并后combineSignal的值：%@",x);
    }];
    //输出：aSignal清理了   合并后combineSignal的值：3-7    合并后combineSignal的值：3-9   bSignal清理了

从结果可以看出此种合并会将第一个信号中最后一个sendnext与后面信号的所有sendnext结合起来作为一个数组，而next触发次数以bSignal中的next次数为主。

然后，介绍一下then的用法，用于连接两个信号，当第一个信号完成，才会连接then返回的信号。

  RACSignal *thenSignal=[aSignal then:^RACSignal *{
        return bSignal;
    }];
    
    [thenSignal subscribeNext:^(id x) {
        NSLog(@"thenSignal的值：%@",x);
    }];
    //输出  thenSignal的值：7   thenSignal的值：9   bSignal清理了  aSignal清理了

then可以用来处理串行的需求，就像一下实例:

 [[[[RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
        NSLog(@"第一步");
        [subscriber sendCompleted];
        return nil;
    }] then:^RACSignal *{
        return [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
            NSLog(@"第二步");
            [subscriber sendCompleted];
            return nil;
        }];
    }] then:^RACSignal *{
        return [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
            NSLog(@"第三步");
            return nil;
        }];
    }] subscribeCompleted:^{
        NSLog(@"完成");
    }];
    //输出：第一步   第二步  第三步

最后，我们看一下aggregateWithStart跟scanWithStart的使用，aggregateWithStart的意思是 从哪个位置开始 进行顺序两值进行操作 最后只有一个被操作后的值，而scanWithStart的意思是 从哪个位置开始 然后每个位置跟前面的值进行操作 它会有根据NEXT的个数来显示对应的值。我们通过具体的代码来看:

    RACSignal *operateSignal=[RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
        [subscriber sendNext:@2];
        [subscriber sendNext:@12];
        [subscriber sendNext:@15];
        [subscriber sendCompleted];
        return nil;
    }];
    
    
    //aggregateWithStar
    [[operateSignal aggregateWithStart:@0 reduce:^id(NSNumber *running, NSNumber *next) {
        return @([running integerValue]+[next integerValue]);
    }] subscribeNext:^(id x) {
        NSLog(@"aggregateWithStart 当前值：%@",x);
    }];
    //输出
    //aggregateWithStart 当前值：29
    
    
    //scanWithStart 
    [[operateSignal scanWithStart:@0 reduce:^id(NSNumber *running, NSNumber *next) {
        return @([running integerValue]+[next integerValue]);
    }] subscribeNext:^(id x) {
        NSLog(@"scanWithStart 当前值：%@",x);
    }];
    //输出
    //scanWithStart 当前值：2
    //scanWithStart 当前值：14
    //scanWithStart 当前值：29

7. 信号队列的使用

信号队列顾名思义就是将一组信号排成队列，挨个调用。Talk is cheap, show you the code .

    //创建3个信号来模拟队列
    RACSignal *signalB = [RACSignal createSignal:^RACDisposable *(id subscriber) {
        [subscriber sendNext:@"喜欢一个人"];
        [subscriber sendCompleted];
        return nil;
    }];
    RACSignal *signalC = [RACSignal createSignal:^RACDisposable *(id subscriber) {
        [subscriber sendNext:@"直接去表白"];
        [subscriber sendCompleted];
        return nil;
    }];
    RACSignal *signalD = [RACSignal createSignal:^RACDisposable *(id subscriber) {
        [subscriber sendNext:@"成功在一起"];
        [subscriber sendCompleted];
        return nil;
    }];
    
    RACSignal *signalGroup = [[signalB concat:signalC] concat:signalD];
    [signalGroup subscribeNext:^(id x) {
        NSLog(@"%@",x);
    }];
    
    //输出：喜欢一个人   直接去表白   成功在一起

以上的代码中，我们使用了concat来连接组队列,concat将几个信号放进一个组里面,按顺序连接每个,每个信号必须执行sendCompleted方法后才能执行下一个信号。此处，我们也可以用merge来处理,merge用来合并队列。

 [[RACSignal merge:@[signalB,signalC,signalD]] subscribeNext:^(id x) {
        NSLog(@"merge:%@",x);
    }];
    //输出：merge:喜欢一个人   merge:直接去表白   merge:成功在一起

concat跟merge的区别是什么呢?
concat每个信号必须执行sendCompleted方法后才能执行下一个信号，而merge不用。

最后的最后，我们看一下信号的压缩zipWith的用法，压缩具有一一对应关系,以2个信号中 消息发送数量少的为主对应。

RACSignal *signalA = [RACSignal createSignal:^RACDisposable *(id subscriber) {
        [subscriber sendNext:@"我想你"];
        [subscriber sendNext:@"我不想你"];
        [subscriber sendNext:@"Test"];
        return nil;
    }];
    RACSignal *signalB = [RACSignal createSignal:^RACDisposable *(id subscriber) {
        [subscriber sendNext:@"嗯"];
        [subscriber sendNext:@"你豁我"];
        return nil;
    }];
  
    [[signalA zipWith:signalB] subscribeNext:^(RACTuple* x) {
        //解包RACTuple中的对象
        RACTupleUnpack(NSString *stringA, NSString *stringB) = x;
        NSLog(@"%@%@", stringA, stringB);
    }];
    //输出：我想你  嗯   我不想你  你豁我

若将此结果于合并作对比，我们可以发现他们只是触发next事件的次数所关联对象不一样，是以信号中next事件数量较少的为主。
发现已经不知不觉介绍了很多了，那就先这样吧，剩下的内容我们下篇文章再聊，欢迎你前来围观。