ReactiveCocoa 的一些高级用法

• 之前已经有两篇文章介绍了ReactiveCocoa的一些见解和用法, 这里也就不再作介绍了
• 其中第一篇文章介绍了ReactiveCocoa关于RACSingle的使用详解
• 第二篇文章介绍了ReactiveCocoa之集合使用详解
• 有兴趣的可以先去看看这两篇文章
• 接下来我们就着重介绍一些Map, concat等高级用法

一. ReactiveCocoa常见操作介绍

1. ReactiveCocoa操作须知

• 所有的信号RACSignal都可以进行操作处理，因为所有操作方法都定义在RACStream.h中，因此只要继承RACStream就有了操作处理方法。

2. ReactiveCocoa操作思想

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

二. 高级操作

1. ReactiveCocoa核心方法bind

• ReactiveCocoa操作的核心方法是bind（绑定）,而且RAC中核心开发方式，也是绑定，之前的开发方式是赋值，而用RAC开发，应该把重心放在绑定，也就是可以在创建一个对象的时候，就绑定好以后想要做的事情，而不是等赋值之后在去做事情。
• 在开发中很少使用bind方法，bind属于RAC中的底层方法，RAC已经封装了很多好用的其他方法，底层都是调用bind，用法比bind简单.
• bind方法简单介绍和使用
  
  • 需求: 监听文本框的内容, 每次输出的时候, 在内容后面品尚字符串"jun", 并显示在label上

方式一: 在返回结果后, 拼接字符串

    @weakify(self)
    [_textField.rac_textSignal subscribeNext:^(NSString * _Nullable x) {
        @strongify(self)
        self.showLabel.text = [NSString stringWithFormat:@"%@+%@", x, @"jun"];
    }];

方式二: 在返回结果前, 拼接字符串, 用bind方法操作

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

• bind方法介绍
  
  • bind方法参数:需要传入一个返回值是RACStreamBindBlock的block参数
  • RACStreamBindBlock是一个block的类型，返回值是信号，参数（value,stop），因此参数的block返回值也是一个block
  • 如下:

typedef RACSignal * _Nullable (^RACSignalBindBlock)(ValueType _Nullable value, BOOL *stop);

• RACStreamBindBlock:
  
  • 参数一(value): 表示接收到信号的原始值，还没做处理
  • 参数二*stop: 用来控制绑定Block，如果*stop = yes,那么就会结束绑定。
  • 返回值：信号，做好处理，在通过这个信号返回出去，一般使用RACReturnSignal,需要手动导入头文件RACReturnSignal.h

@interface RACReturnSignal<__covariant ValueType> : RACSignal<ValueType>

+ (RACSignal<ValueType> *)return:(ValueType)value;

@end

• bind方法使用步骤:
  
  • 传入一个返回值RACStreamBindBlock的block
  • 描述一个RACStreamBindBlock类型的bindBlock作为block的返回值。
  • 描述一个返回结果的信号，作为bindBlock的返回值。
  • 注意：在bindBlock中做信号结果的处理
• bind底层实现:
  
  • 源信号调用bind,会重新创建一个绑定信号。
  • 当绑定信号被订阅，就会调用绑定信号中的didSubscribe，生成一个bindingBlock。
  • 当源信号有内容发出，就会把内容传递到bindingBlock处理，调用bindingBlock(value,stop)
  • 调用bindingBlock(value,stop)，会返回一个内容处理完成的信号（RACReturnSignal）。
  • 订阅RACReturnSignal，就会拿到绑定信号的订阅者，把处理完成的信号内容发送出来

2. 映射(flattenMap,Map)

• flattenMap，Map用于把源信号内容映射成新的内容
• 在Swift中系统API就已经有了这些函数的用法, 详情可参考我的这篇文章Swift函数式编程之Map&Reduce&Filter

2-1. flattenMap

把源信号的内容映射成一个新的信号，信号可以是任意类型
- flattenMap使用步骤:
- 传入一个block，block类型是返回值RACStream，参数value
- 参数value就是源信号的内容，拿到源信号的内容做处理
- 包装成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的返回信号，就会拿到绑定信号的订阅者，把处理完成的信号内容发送出来

- (__kindof RACStream *)flattenMap:(__kindof RACStream * (^)(id value))block {
    Class class = self.class;

    return [[self bind:^{
        return ^(id value, BOOL *stop) {
            id stream = block(value) ?: [class empty];
            NSCAssert([stream isKindOfClass:RACStream.class], @"Value returned from -flattenMap: is not a stream: %@", stream);

            return stream;
        };
    }] setNameWithFormat:@"[%@] -flattenMap:", self.name];
}

简单使用

    @weakify(self)
    [[_textField.rac_textSignal flattenMap:^__kindof RACSignal * _Nullable(NSString * _Nullable value) {
        //源信号发出的时候，就会调用这个block。
        // 返回值：绑定信号的内容.
        return [RACReturnSignal return:[NSString stringWithFormat:@"flat输出: %@", value]];
    }] subscribeNext:^(id  _Nullable x) {
        @strongify(self)
        //订阅绑定信号, 每当原信号发送内容, 处理后, 就会调用这个black
        self.showLabel.text = x;
        NSLog(@"%@", x);
    }];

2-2. Map

Map作用:把源信号的值映射成一个新的值

• Map使用步骤:
  
  • 传入一个block,类型是返回对象，参数是value
  • value就是源信号的内容，直接拿到源信号的内容做处理
  • 把处理好的内容，直接返回就好了，不用包装成信号，返回的值，就是映射的值。
• Map底层实现:
  
  • Map底层其实是调用flatternMap, Map中block中的返回的值会作为flatternMap中block中的值。
  • 当订阅绑定信号，就会生成bindBlock。
  • 当源信号发送内容，就会调用bindBlock(value, *stop)
  • 调用bindBlock，内部就会调用flattenMap的block
  • flattenMap的block内部会调用Map中的block，把Map中的block返回的内容包装成返回的信号。
  • 返回的信号最终会作为bindBlock中的返回信号，当做bindBlock的返回信号。
  • 订阅bindBlock的返回信号，就会拿到绑定信号的订阅者，把处理完成的信号内容发送出来

- (__kindof RACStream *)map:(id (^)(id value))block {
    NSCParameterAssert(block != nil);

    Class class = self.class;

    return [[self flattenMap:^(id value) {
        return [class return:block(value)];
    }] setNameWithFormat:@"[%@] -map:", self.name];
}

简单使用

    //Map
    [[_textField.rac_textSignal map:^id _Nullable(NSString * _Nullable value) {
        return [NSString stringWithFormat:@"map输出: %@", value];
    }] subscribeNext:^(id  _Nullable x) {
        @strongify(self)
        self.showLabel.text = x;
        NSLog(@"%@", x);
    }];

    //对数组的处理
    NSArray *arr = @[@"2", @"3", @"a", @"g"];
    RACSequence *sequence = [arr.rac_sequence map:^id _Nullable(id  _Nullable value) {
        return [NSString stringWithFormat:@"-%@-", value];
    }];

    NSLog(@"%@", [sequence array]);

    /*输出: 
    2018-03-24 14:13:32.421337+0800 ReactiveObjc[9043:492929] (
        "-2-",
        "-3-",
        "-a-",
        "-g-"
    )
    */

2-3. FlatternMap 和 Map的区别

• FlatternMap中的Block返回信号。
• Map中的Block返回对象。
• 开发中，如果信号发出的值不是信号，映射一般使用Map
• 开发中，如果信号发出的值是信号，映射一般使用FlatternMap
• 信号中信号
  
  • 当一个信号需要返回另一个信号中的值的时候
  • 让我们来看看下面这个例子

#pragma 信号中信号
- (void)singleAndSingle {
    //创建信号中信号
    RACSubject *sonSingle = [RACSubject subject];
    RACSubject *single = [RACSubject subject];

    [[sonSingle flattenMap:^__kindof RACSignal * _Nullable(id  _Nullable value) {
        //sonSingle发送信号时, 才会调用
        return value;
    }] subscribeNext:^(id  _Nullable x) {
        //只有sonSingle的子信号, 大宋消息时, 才会调用
        NSLog(@"输出: %@", x);
    }];

    //信号中信号发送子信号
    [sonSingle sendNext:single];
    //子信号发送内容
    [single sendNext:@123];
}

3. 组合

3-1. concat

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

//让我们先看一下一般的正常操作
- (void)setConcatAction {
    //当需要按顺序执行的时候: 先执行A, 在执行B
    RACSubject *subjectA = [RACSubject subject];
    RACSubject *subjectB = [RACReplaySubject subject];

    NSMutableArray *array = [NSMutableArray array];

    //订阅信号
    [subjectA subscribeNext:^(id  _Nullable x) {
        [array addObject:x];
    }];
    [subjectB subscribeNext:^(id  _Nullable x) {
        [array addObject:x];
    }];

    //发送信号
    [subjectB sendNext:@"B"];
    [subjectA sendNext:@"A"];
    [subjectA sendCompleted];

    //输出: [B, A]
    NSLog(@"%@", array);
}

• 很明显, 上述的结果并未达到我们的需求: 限制性A, 在执行B
• 下面我们看看使用concat后的执行情况

- (void)setConcatAction {
    //当需要按顺序执行的时候: 先执行A, 在执行B
    RACSubject *subC = [RACSubject subject];
    RACSubject *subD = [RACReplaySubject subject];

    NSMutableArray *array2 = [NSMutableArray array];

    //订阅信号
    [[subC concat:subD] subscribeNext:^(id  _Nullable x) {
        [array2 addObject:x];
    }];

    //发送信号
    [subD sendNext:@"D"];
    [subC sendNext:@"C"];
    [subC sendCompleted];

    //输出: [C, D]
    NSLog(@"%@", array2);
}

• 可以看到, 输出的结果和我们预想的一样, 顺序输出
• 那么, concat的底层到底是如何实现的呢?

- (RACSignal *)concat:(RACSignal *)signal {
    return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
        RACCompoundDisposable *compoundDisposable = [[RACCompoundDisposable alloc] init];

        RACDisposable *sourceDisposable = [self subscribeNext:^(id x) {
            [subscriber sendNext:x];
        } error:^(NSError *error) {
            [subscriber sendError:error];
        } completed:^{
            RACDisposable *concattedDisposable = [signal subscribe:subscriber];
            [compoundDisposable addDisposable:concattedDisposable];
        }];

        [compoundDisposable addDisposable:sourceDisposable];
        return compoundDisposable;
    }] setNameWithFormat:@"[%@] -concat: %@", self.name, signal];
}

• concat底层实现:
  
  • 当拼接信号被订阅，就会调用拼接信号的didSubscribe
  • didSubscribe中，会先订阅第一个源信号subjectA
  • 会执行第一个源信号subjectA的didSubscribe
  • 第一个源信号subjectA的didSubscribe中发送值，就会调用第一个源信号subjectA订阅者的nextBlock, 通过拼接信号的订阅者把值发送出来.
  • 第一个源信号subjectA的didSubscribe中发送完成，就会调用第一个源信号subjectA订阅者的completedBlock,订阅第二个源信号subjectB这时候才激活subjectB
  • 订阅第二个源信号subjectB,执行第二个源信subjectB号的didSubscribe
  • 第二个源信号subjectB的didSubscribe中发送值,就会通过拼接信号的订阅者把值发送出来.

3-2. then

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

- (RACSignal *)then:(RACSignal * (^)(void))block {
    NSCParameterAssert(block != nil);

    return [[[self
        ignoreValues]
        concat:[RACSignal defer:block]]
        setNameWithFormat:@"[%@] -then:", self.name];
}

//ignoreValues底层实现
- (RACSignal *)ignoreValues {
    return [[self filter:^(id _) {
        return NO;
    }] setNameWithFormat:@"[%@] -ignoreValues", self.name];
}

• 实现原理
  
  • 底层会调用filter过滤掉本身信号发出的值(filter后面会讲到)
  • 然后再使用concat连接then返回的信号
  • 下面是测试用例

- (void)setThenAction {
    RACSubject *subjectA = [RACReplaySubject subject];
    RACSubject *subjectB = [RACReplaySubject subject];

    //发送信号
    [subjectA sendNext:@"A"];
    [subjectA sendCompleted];
    [subjectB sendNext:@"B"];

    //订阅信号
    [[subjectA then:^RACSignal * _Nonnull{
        return subjectB;
    }] subscribeNext:^(id  _Nullable x) {
        NSLog(@"%@", x);
    }];

    //这里只会输出: B
    //不会输出: A
}

3-3. merge

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

- (RACSignal *)merge:(RACSignal *)signal {
    return [[RACSignal
        merge:@[ self, signal ]]
        setNameWithFormat:@"[%@] -merge: %@", self.name, signal];
}

+ (RACSignal *)merge:(id<NSFastEnumeration>)signals {
    NSMutableArray *copiedSignals = [[NSMutableArray alloc] init];
    for (RACSignal *signal in signals) {
        [copiedSignals addObject:signal];
    }

    return [[[RACSignal
        createSignal:^ RACDisposable * (id<RACSubscriber> subscriber) {
            for (RACSignal *signal in copiedSignals) {
                [subscriber sendNext:signal];
            }

            [subscriber sendCompleted];
            return nil;
        }]
        flatten]
        setNameWithFormat:@"+merge: %@", copiedSignals];
}

• 底层实现
  
  • 1.合并信号被订阅的时候，就会遍历所有信号，并且发出这些信号。
  • 2.每发出一个信号，这个信号就会被订阅
  • 3.也就是合并信号一被订阅，就会订阅里面所有的信号。
  • 4.只要有一个信号被发出就会被监听。

- (void)setMergeAction {
    // 只要想无序的整合信号数据
    RACSubject *subjectA = [RACSubject subject];
    RACSubject *subjectB = [RACSubject subject];
    RACSubject *subjectC = [RACSubject subject];

    //合并信号
    RACSignal *single = [[subjectA merge:subjectB] merge:subjectC];

    //订阅信号
    [single subscribeNext:^(id  _Nullable x) {
        NSLog(@"%@", x);
    }];

    //发出消息
    [subjectA sendNext:@"A"];
    [subjectC sendNext:@"C"];
    [subjectB sendNext:@"B"];
}

//输出结果(分别输出): A, C, B

3-4. zipWith

把两个信号压缩成一个信号，只有当两个信号同时发出信号内容时，并且把两个信号的内容合并成一个元组，才会触发压缩流的next事件
- 底层实现:
- 1.定义压缩信号，内部就会自动订阅subjectA，subjectB
- 2.每当subjectA或者subjectB发出信号，就会判断subjectA，subjectB有没有发出个信号，有就会把最近发出的信号都包装成元组发出。

- (void)setZipwithAction {
    // 只要想无序的整合信号数据
    RACSubject *subjectA = [RACSubject subject];
    RACSubject *subjectB = [RACSubject subject];

    //合并信号
    RACSignal *single = [subjectA zipWith:subjectB];

    //订阅信号
    [single subscribeNext:^(id  _Nullable x) {
        NSLog(@"%@", x);
    }];

    //发出消息
    [subjectA sendNext:@"A"];
    [subjectB sendNext:@"B"];

    /* 输出:
     (A, B)
     */
}

3-5. combineLatest

• 将多个信号合并起来，并且拿到各个信号的最新的值
• 必须每个合并的信号至少都有过一次sendNext，才会触发合并的信号
• 这里我们考虑这样一个需求: 在登录页面, 只有在账号密码都输入的情况下, 登录按钮才可点击, 否则不可点击
• 正常情况下我们需要监听每一个文本框的输入
• 下面我们来看一下combineLatest控制登录按钮是否可点击

- (void)setCombineLatest {
    //把两个信号组合成一个信号,跟zip一样，没什么区别
    RACSignal *single = [_accountText.rac_textSignal combineLatestWith:_passwordText.rac_textSignal];

    [single subscribeNext:^(id  _Nullable x) {
        RACTupleUnpack(NSString *account, NSString *password) = x;

        _loginButton.enabled = account.length > 0 && password.length > 0;
    }];
}

• 底层实现：
  
  • 1.当组合信号被订阅，内部会自动订阅两个信号,必须两个信号都发出内容，才会被触发。(而zip, 是两个信号同事发出内容, 才会触发)
  • 2.把两个信号组合成元组发出。

3-6. reduce

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

这里我们把上面的代码, 使用RACSingle的一个类方法优化一下

- (void)setReduceAction {
    // reduce:把多个信号的值,聚合为一个值
    RACSignal *single = [RACSignal combineLatest:@[_accountText.rac_textSignal, _passwordText.rac_textSignal] reduce:^id (NSString *account, NSString *password){
        return @(account.length > 0 && password.length > 0);
    }];

    [single subscribeNext:^(id  _Nullable x) {
        _loginButton.enabled = [x boolValue];
    }];
}

• RACSingle类方法
  
  • 参数一: (id<NSFastEnumeration>)类型
  • NSFastEnumeration我们在上一篇文章ReactiveCocoa之集合使用详解02中简单介绍过
  • NSFastEnumeration: 是一个协议, 所有遵循该协议的类, 均可视为一个数组, 例如NSArray
  • 故这里, 应该传一个包含RACSingle信号的数组
  • 参数二: (RACGenericReduceBlock)reduceBlock是一个black

typedef ValueType _Nonnull (^RACGenericReduceBlock)();

//reduceblcok中的参数，有多少信号组合，reduceblcok就有多少参数，每个参数就是之前信号发出的内容

这里用一个宏, 急需将上面的代码简化一下

- (void)setReduceAction {

    RAC(_loginButton, enabled) = [RACSignal combineLatest:@[_accountText.rac_textSignal, _passwordText.rac_textSignal] reduce:^id (NSString *account, NSString *password){
        return @(account.length > 0 && password.length > 0);
    }];
}

上面用到了一个宏RAC, 这里暂不赘述, 以后会集中整理一下 RAC中的宏, 具体实现如下

#define RAC(TARGET, ...) \
    metamacro_if_eq(1, metamacro_argcount(__VA_ARGS__)) \
        (RAC_(TARGET, __VA_ARGS__, nil)) \
        (RAC_(TARGET, __VA_ARGS__))

/// Do not use this directly. Use the RAC macro above.
#define RAC_(TARGET, KEYPATH, NILVALUE) \
    [[RACSubscriptingAssignmentTrampoline alloc] initWithTarget:(TARGET) nilValue:(NILVALUE)][@keypath(TARGET, KEYPATH)]

4. 过滤

4-1. filter

过滤信号, 过滤掉不符合条件的信号

- (void) filterAction{
    //filter
    //截取等于11位的字符
    [[_accountText.rac_textSignal filter:^BOOL(NSString * _Nullable value) {
        //类似手机号的输入, 只有等于11位的时候才返回true
        return value.length == 11;
    }]subscribeNext:^(NSString * _Nullable x) {
        //这里只会返回等于11位的字符
        NSLog(@"filter = %@", x);
    }];
}

filter底层是调用的flatMap方法, 如下:

- (__kindof RACStream *)filter:(BOOL (^)(id value))block {
    NSCParameterAssert(block != nil);

    Class class = self.class;

    return [[self flattenMap:^ id (id value) {
        if (block(value)) {
            return [class return:value];
        } else {
            return class.empty;
        }
    }] setNameWithFormat:@"[%@] -filter:", self.name];
}

4-2. ignore

忽略掉某些特定值的信号

- (void)setIgnoreAction {
    ///ignore
    //这里的测试只有第一个字符位: m的时候能看到效果
    [[_accountText.rac_textSignal ignore:@"m"] subscribeNext:^(NSString * _Nullable x) {
        NSLog(@"ignore = %@", x);
    }];

    //ignoreValues: 忽略所有信号
    [[_passwordText.rac_textSignal ignoreValues] subscribeNext:^(id  _Nullable x) {
        NSLog(@"allIgnore = %@", x);
    }];
}

ignore方法的底层都是调用的filter方法

//ignore
- (__kindof RACStream *)ignore:(id)value {
    return [[self filter:^ BOOL (id innerValue) {
        return innerValue != value && ![innerValue isEqual:value];
    }] setNameWithFormat:@"[%@] -ignore: %@", self.name, RACDescription(value)];
}

//ignoreValues
- (RACSignal *)ignoreValues {
    return [[self filter:^(id _) {
        return NO;
    }] setNameWithFormat:@"[%@] -ignoreValues", self.name];
}

4-3. distinctUntilChanged

• 当上一次的值和当前的值有明显的变化就会发出信号，否则会被忽略掉。
• 在开发中，刷新UI经常使用，只有两次数据不一样才需要刷新

//distinctUntilChanged
- (void)setdistinctUntilChanged {
    //创建信号
    RACSubject *subject = [RACSubject subject];

    //订阅
    [[subject distinctUntilChanged] subscribeNext:^(id  _Nullable x) {
        NSLog(@"distinctUntilChanged = %@", x);
    }];

    [subject sendNext:@12];
    [subject sendNext:@12];
    [subject sendNext:@23];

    /*输出结果:只会输出两次
     distinctUntilChanged = 12
     distinctUntilChanged = 23
     */
}

distinctUntilChanged底层是调用的bind高级用法

- (__kindof RACStream *)distinctUntilChanged {
    Class class = self.class;

    return [[self bind:^{
        __block id lastValue = nil;
        __block BOOL initial = YES;

        return ^(id x, BOOL *stop) {
            if (!initial && (lastValue == x || [x isEqual:lastValue])) return [class empty];

            initial = NO;
            lastValue = x;
            return [class return:x];
        };
    }] setNameWithFormat:@"[%@] -distinctUntilChanged", self.name];
}

4-4. take

从开始一共取N次的信号, 当遇到sendCompleted语句执行时, 会提前停止发送信号

- (void)setTakeAndTakeLast {
    //take
    RACSubject *subject1 = [RACSubject subject];
    [[subject1 take:2] subscribeNext:^(id  _Nullable x) {
        NSLog(@"%@", x);
    }];

    [subject1 sendNext:@1];
    [subject1 sendNext:@2];
    [subject1 sendCompleted];
    [subject1 sendNext:@3];

    //分别输出: 1, 2
}

//如果上面发送信号的代码调整为
    [subject1 sendNext:@1];
    [subject1 sendCompleted];
    [subject1 sendNext:@2];
    [subject1 sendNext:@3];

    //那么输出结果将会,只输出: 1

4-5. takeLast

取调用sendCompleted之前的N次信号,前提条件，订阅者必须调用sendCompleted，否则不会执行任何操作

- (void)setTakeAndTakeLast {
    //takeLast
    RACSubject *subject1 = [RACSubject subject];
    [[subject1 takeLast:2] subscribeNext:^(id  _Nullable x) {
        NSLog(@"%@", x);
    }];

    [subject1 sendNext:@1];
    [subject1 sendNext:@2];
    [subject1 sendNext:@3];
    [subject1 sendCompleted];
}

4-6. takeUntil

只要传入的信号发送完成或者subject2开始发送信号的时候,就不会再接收信号的内容

- (void)setTakeAndTakeLast {
    //takeUntil
    RACSubject *subject1 = [RACSubject subject];
    RACSubject *subject2 = [RACSubject subject];

    [[subject1 takeUntil:subject2] subscribeNext:^(id  _Nullable x) {
        NSLog(@"%@", x);
    }];

    [subject1 sendNext:@11];
    [subject1 sendNext:@12];
//    [subject1 sendCompleted];
    [subject1 sendNext:@13];
    [subject2 sendNext:@"21"];
    [subject2 sendNext:@"22"];

    //这样会输出: 11, 12, 13
    //当sendCompleted取消注释的时候, 只会输出: 11, 12
}

4-7. switchToLatest

• 主要用于信号的信号, 有时候也会发出信号, 会在信号的信号中获取其发送的最新的信号
• 方法的底层是调用了flattenMap方法

- (RACSignal *)switchToLatest {
    return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
        RACMulticastConnection *connection = [self publish];

        RACDisposable *subscriptionDisposable = [[connection.signal
            flattenMap:^(RACSignal *x) {
                NSCAssert(x == nil || [x isKindOfClass:RACSignal.class], @"-switchToLatest requires that the source signal (%@) send signals. Instead we got: %@", self, x);

                // -concat:[RACSignal never] prevents completion of the receiver from
                // prematurely terminating the inner signal.
                return [x takeUntil:[connection.signal concat:[RACSignal never]]];
            }]
            subscribe:subscriber];

        RACDisposable *connectionDisposable = [connection connect];
        return [RACDisposable disposableWithBlock:^{
            [subscriptionDisposable dispose];
            [connectionDisposable dispose];
        }];
    }] setNameWithFormat:@"[%@] -switchToLatest", self.name];
}

下面我们看一下具体的使用示例

- (void)setswitchToLatest {
    //信号的信号
    RACSubject *subject1 = [RACSubject subject];
    RACSubject *subject2 = [RACSubject subject];

    //获取信号中信号最近发出信号，订阅最近发出的信号
    [[subject1 switchToLatest] subscribeNext:^(id  _Nullable x) {
        NSLog(@"%@", x);
    }];

    //发送信号
    [subject1 sendNext:subject2];
    [subject2 sendNext:@"信号中信号"];

    //最终结果输出: "信号中信号"
}

4-8. skip

跳过N个信号后, 再开始订阅信号

- (void)setSkipAction {
    //创建信号
    RACSubject *subject = [RACSubject subject];

    //订阅信号
    //要求跳过2个信号
    [[subject skip:2] subscribeNext:^(id  _Nullable x) {
        NSLog(@"%@", x);
    }];

    //发送信号
    [subject sendNext:@1];
    [subject sendNext:@2];
    [subject sendNext:@3];
    [subject sendNext:@4];

    //因为上面跳过了两个信号, 所以这里只会输出: 3, 4
}

5. 定时操作

5-1. interval

定时器, 每隔一段时间发出信号

    //RAC定时器, 每隔一段时间执行一次
    [[RACSignal interval:1 onScheduler:[RACScheduler mainThreadScheduler]] subscribeNext:^(NSDate * _Nullable x) {
        NSLog(@"定时器");
    }];

其中RACScheduler是RAC中管理线程的类

5-2. delay

延迟一段时间都发送信号

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

5-3. timeout

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

    //timeout: 超时, 可以让一个信号在一定时间后自动报错
    RACSignal *single = [[RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        return nil;
    }] timeout:2 onScheduler:[RACScheduler currentScheduler]];

    [single subscribeNext:^(id  _Nullable x) {
        NSLog(@"%@", x);
    } error:^(NSError * _Nullable error) {
        //2秒后自动调用
        NSLog(@"%@", error);
    }];

6. 重复操作

6-1. retry

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

- (void)setResertAction {
    //retry
    __block int i = 0;
    [[[RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        if (i == 5) {
            [subscriber sendNext:@12];
        } else {
            NSLog(@"发生错误");
            [subscriber sendError:nil];
        }
        i++;

        return nil;
    }] retry] subscribeNext:^(id  _Nullable x) {
        NSLog(@"%@", x);
    } error:^(NSError * _Nullable error) {
        NSLog(@"%@", error);
    }];


    /*输出结果
     2018-03-30 15:44:08.412860+0800 ReactiveObjc[4125:341376] 发生错误
     2018-03-30 15:44:08.461105+0800 ReactiveObjc[4125:341376] 发生错误
     2018-03-30 15:44:08.461897+0800 ReactiveObjc[4125:341376] 发生错误
     2018-03-30 15:44:08.462478+0800 ReactiveObjc[4125:341376] 发生错误
     2018-03-30 15:44:08.462913+0800 ReactiveObjc[4125:341376] 发生错误
     2018-03-30 15:44:08.463351+0800 ReactiveObjc[4125:341376] 12
     */
}

6-2. replay

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

    //replay
    RACSignal *single = [[RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        [subscriber sendNext:@23];
        [subscriber sendNext:@34];

        return nil;
    }] replay];

    [single subscribeNext:^(id  _Nullable x) {
        NSLog(@"第一次订阅-%@", x);
    }];

    [single subscribeNext:^(id  _Nullable x) {
        NSLog(@"第二次订阅-%@", x);
    }];

    /*输出结果:
     2018-03-30 15:51:20.115052+0800 ReactiveObjc[4269:361568] 第一次订阅-23
     2018-03-30 15:51:20.115195+0800 ReactiveObjc[4269:361568] 第一次订阅-34
     2018-03-30 15:51:20.115278+0800 ReactiveObjc[4269:361568] 第二次订阅-23
     2018-03-30 15:51:20.115352+0800 ReactiveObjc[4269:361568] 第二次订阅-34
     */

6-3. throttle

节流:当某个信号发送比较频繁时，可以使用节流, 在一定时间（1秒）内，不接收任何信号内容，过了这个时间（1秒）获取最后发送的信号内容发出。

    RACSubject *subject = [RACSubject subject];

    [[subject throttle:0.001] subscribeNext:^(id  _Nullable x) {
        NSLog(@"%@", x);
    }];

    [subject sendNext:@10];
    [subject sendNext:@11];
    [subject sendNext:@12];
    [subject sendNext:@13];
    [subject sendNext:@14];
    [subject sendNext:@15];
    [subject sendNext:@16];
    [subject sendNext:@17];
    [subject sendNext:@18];

    //这里因为执行的速度非常快, 所以这里输出的结果只有最后一个: 18

• 以上就是RAC中的一些常用的高级用用法具体讲解和使用示例
• 如有不足之处, 还请多多指教, 后期会持续更新相关知识点
• 下面是RAC相关的两篇文章
  
  • ReactiveCocoa使用详解01
  • ReactiveCocoa之集合使用详解02