RAC初探

函数式编程

主要思想是把运算过程尽量写成一系列嵌套的函数调用。
特点

  • 函数式编程要求只使用表达式，不使用语句。也就是说，每一步都是单纯的运算，而且都有返回值。
  • 函数的运行不依赖于外部变量或状态，只依赖于输入的参数，任何时候只要参数相同，引用函数所得到的返回值总是相同的。
响应式编程

例如，在命令式编程环境中a = b + c表示将表达式的结果赋给 a，而之后改变 b 或 c 的值不会影响 a。但在响应式编程中，a 的值会随着 b 或 c 的更新而更新。
在响应式编程当中，a = b + c声明的是一种绑定关系。（a 与 b、c 绑定起来了，所以 b、c 的变化会影响 a，这也就是所谓变化传播）

什么是RAC？

RAC其实就是一个三方库ReactiveObjC，只不过在这个库中把苹果的消息响应机制给整合了。RAC是函数式响应式编程(简称FRP)。它能给我们解决什么问题呢，首先它能在某些情况大大减少代码量，然后把响应与事件的触发整和到一起，通过block回调的形式触发。
我们常用的Target-Action、KVO、通知、代理等一些操作都可以用RAC进行替代。

RAC框架结构
RAC的导入

这里使用cocoaPods导入，版本是3.0.0。在Podfile文件里写入pod 'ReactiveObjC', '~> 3.0.0'，再在命令行中执行pod install，项目中引入<ReactiveObjC.h> 头文件即可开始使用。

RAC初级用法

KVO监听name属性变化

KVO正常使用

// 声明name属性
@property (nonatomic, copy) NSString *name;

// 添加监听addObserver
[self addObserver:self forKeyPath:@"name" options:(NSKeyValueObservingOptionNew) context:NULL];

// 在方法 observeValueForKeyPath中实现监听到属性值变化后的处理
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context {
    if ([@"name" isEqualToString: keyPath]) {
        NSLog(@"%@", change);
    }
}

// 在析构函数中移除监听removeObserver
- (void)dealloc {
    [self removeObserver:self forKeyPath:@"name"];
}

// 触发按钮等方式修改name属性值
self.name = @"hello world";

// 日志打印
2022-11-02 22:58:42.677795+0800 001---RAC初探[27850:25205494] {
    kind = 1;
    new = "hello world";
}

RAC使用

// RAC的好处
// 1. 有好的提示
// 2. 代码简洁
// 3. 代码逻辑与功能逻辑集中在一块，方便阅读
// 4. 不需要在dealloc方法中移除监听
self.name = @"hello world";
[RACObserve(self, name) subscribeNext:^(id  _Nullable x) {
    NSLog(@"%@",x);
}];
通知 NSNotificationCenter

通知正常使用

// 添加键盘弹出的通知addObserver
[[NSNotificationCenter defaultCenter] addObserver:self
                                             selector:@selector(keyboardWillShow:)
                                                 name:UIKeyboardWillShowNotification
                                               object:nil];

// 实现通知 keyboardWillShow
- (void) keyboardWillShow:(NSNotification *)note {
    NSLog(@"键盘弹出了");
}

// 在析构函数中移除通知removeObserver
[[NSNotificationCenter defaultCenter] removeObserver:self name:UIKeyboardWillShowNotification object:nil];

RAC使用

[[[NSNotificationCenter defaultCenter] rac_addObserverForName:UIKeyboardWillShowNotification object:nil] subscribeNext:^(NSNotification * _Nullable x) {
    NSLog(@"%@",x);
}];
代理 delegate

代理正常使用

// 以 UITextField 的 textFieldDidBeginEditing 代理为例
self.textField.delegate = self;

// 代理方法
- (void)textFieldDidBeginEditing:(UITextField *)textField {
    NSLog(@"开始编辑");
}

RAC使用

[[self rac_signalForSelector:@selector(textFieldDidBeginEditing:) fromProtocol:@protocol(UITextFieldDelegate)] subscribeNext:^(RACTuple * _Nullable x) {
    NSLog(@"%@",x);
}];
self.textField.delegate = self;
UIButton 按钮点击事件

按钮点击正常使用

// 为按钮添加方法 addTarget
[self.button addTarget:self action:@selector(onBtnClick:) forControlEvents:UIControlEventTouchUpInside];

// 实现按钮的点击方法onBtnClick
- (void)onBtnClick:(UIButton *)sender {
    NSLog(@"点击按钮了");
}

RAC使用

[[self.button rac_signalForControlEvents:UIControlEventTouchUpInside] subscribeNext:^(__kindof UIControl * _Nullable x) {
    NSLog(@"%@",x);
}];
UITextField监听输入内容

RAC使用监听TextField输入的内容

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

// textField输入内容，控制台打印信息如下
2022-11-07 22:53:43.285177+0800 001---RAC初探[2122:58239] 1
2022-11-07 22:53:43.454581+0800 001---RAC初探[2122:58239] 11
2022-11-07 22:53:43.647145+0800 001---RAC初探[2122:58239] 111
手势 UITapGestureRecognizer

RAC使用

UITapGestureRecognizer *tap = [[UITapGestureRecognizer alloc] init];
self.label.userInteractionEnabled = YES;
[self.label addGestureRecognizer:tap];

[tap.rac_gestureSignal subscribeNext:^(__kindof UIGestureRecognizer * _Nullable x) {
    NSLog(@"%@",x);
}];

信号的产生是一个冷信号，只有订阅了才是热信号，subscribeNext回调就相当于订阅信号。

数组和字典的遍历 - 序列sequence
  • RAC遍历数组
NSArray *array = @[@"aaa",@"bbb",@"ccc"];
    
[array.rac_sequence.signal subscribeNext:^(id  _Nullable x) {
    NSLog(@"%@",x);
}];

// 打印日志
2022-11-07 23:06:13.476959+0800 001---RAC初探[2381:66330] aaa
2022-11-07 23:06:13.477248+0800 001---RAC初探[2381:66330] bbb
2022-11-07 23:06:13.477466+0800 001---RAC初探[2381:66330] ccc
  • RAC遍历字典
NSDictionary *dict = @{@"key":@"小明",@"age":@"18",@"gender":@"1"};
    
[dict.rac_sequence.signal subscribeNext:^(id  _Nullable x) {
    //元祖
    NSLog(@"%@",x);
    RACTwoTuple *tuple = (RACTwoTuple *)x;
    NSLog(@"key == %@ , value = %@",tuple[0],tuple[1]);
}];

// 打印日志
2022-11-07 23:07:10.594735+0800 001---RAC初探[2425:67567] <RACTwoTuple: 0x6000012f8660> (
    key,
    "\U5c0f\U660e"
)
2022-11-07 23:07:10.595465+0800 001---RAC初探[2425:67567] key == key , value = 小明
2022-11-07 23:07:10.597160+0800 001---RAC初探[2425:67567] <RACTwoTuple: 0x6000012f4680> (
    age,
    18
)
2022-11-07 23:07:10.597699+0800 001---RAC初探[2425:67567] key == age , value = 18
2022-11-07 23:07:10.598388+0800 001---RAC初探[2425:67567] <RACTwoTuple: 0x6000012f04b0> (
    gender,
    1
)
2022-11-07 23:07:10.598682+0800 001---RAC初探[2425:67567] key == gender , value = 1
RAC最基本的用法流程

创建信号、订阅信号、发送信号

//1:创建信号
RACSignal *signal = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
    //subscriber 对象不是一个对象
    //3:发送信号
    [subscriber sendNext:@"hello world"];
        
    //请求网络 失败 error
    NSError *error = [NSError errorWithDomain:NSURLErrorDomain code:10086 userInfo:@{@"key":@"10086错误"}];
    [subscriber sendError:error];

    // RACDisposable 销毁
    return [RACDisposable disposableWithBlock:^{
        NSLog(@"销毁了");
    }];
}];

//2:订阅信号
[signal subscribeNext:^(id  _Nullable x) {
    NSLog(@"%@",x);
}];
//订阅错误信号
[signal subscribeError:^(NSError * _Nullable error) {
    NSLog(@"%@",error);
}];

RAC绑定UI简单使用

  • UIImageView的显示随着UITextField输入的内容而改变
// 图片绑定在textField上
@weakify(self);
[self.textField.rac_textSignal subscribeNext:^(NSString * _Nullable x) {
    @strongify(self);
    self.imageView.image = [UIImage imageNamed:[NSString stringWithFormat:"%@", x]];
}];
  • 点击按钮检测UITextField输入内容是否正确
[[self.button rac_signalForControlEvents: UIControlEventTouchUpInside] subscribeNext:^(__kindof UIControl * _Nullable x) {
    if ([self.textField.text isEqualToString:@"123"]) {
        NSLog(@"fail");
    } else {
        NSLog(@"success");
    }
}];

通过绑定UI正向传递数据：通过绑定UI，一旦UI发生任何变化就会形成信号，有了信号我们就可以订阅，最后可以在订阅里面做绑定过来的事件的回调。

RAC高阶函数

  • 信号映射：map与flattenMap
  • 信号过滤：filter、ignore、distinctUntilChanged
  • 信号合并： combineLatest、reduce、merge、zipWith
  • 信号连接：concat、then
  • 信号操作时间：timeout、interval、dely
  • 信号取值：take、takeLast、takeUntil
  • 信号跳过：skip
  • 信号发送顺序：donext、cocompleted
  • 获取信号中的信号：switchToLatest
  • 信号错误重试：retry
信号映射

flattenMap作用:
把源信号的内容映射成一个新的信号，信号可以是任意类型。

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

- (void)testMapFlattenMap{
    [[self.textField.rac_textSignal filter:^BOOL(NSString * _Nullable value) {
        return YES;
    }] subscribeNext:^(NSString * _Nullable x) {
        NSLog(@"filter == %@",x);
    }];
    
    
    [[self.textField.rac_textSignal map:^id _Nullable(NSString * _Nullable value) {
        return nil;
    }] subscribeNext:^(id  _Nullable x) {
        NSLog(@"map == %@",x);
    }];

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

// 打印日志
2022-11-22 17:25:47.505881+0800 001---RAC初探[2341:63531] filter == 1
2022-11-22 17:25:47.506094+0800 001---RAC初探[2341:63531] map == (null)
2022-11-22 17:25:47.506318+0800 001---RAC初探[2341:63531] 1
2022-11-22 17:25:47.506493+0800 001---RAC初探[2341:63531] flattenMap == 输出:1
信号过滤

filter:过滤信号，使用它可以获取满足条件的信号。每次信号发出，会先执行过滤条件判断。

- (void)testFilter{
    RACSignal *signal = [self.textField.rac_textSignal filter:^BOOL(NSString * _Nullable value) {
        if (self.textField.text.length>6) {
            self.textField.text = [self.textField.text substringToIndex:6];
        }
        NSLog(@"value == %@",value);
        return value.length<6;
    }];
    
    [signal subscribeNext:^(id  _Nullable x) {
        self.textField.text = x;
        NSLog(@"x== %@",x);
    }];
}

// 当textField输入内容长度超过6个时，[signal subscribeNext]就不会执行

内部调用filter过滤，忽略掉ignore的值

- (void)testIgnore{
    [[self.textField.rac_textSignal ignore:@"c"] subscribeNext:^(NSString * _Nullable x) {
        NSLog(@"%@",x);
    }];
}

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

- (void)testDistinctUntilChanged{
    RACSubject *subject = [RACSubject subject];
    [[subject distinctUntilChanged] subscribeNext:^(id x) {
        NSLog(@"%@", x);
    }];
    // 发送信号
    [subject sendNext:@1];
    [subject sendNext:@2];
    [subject sendNext:@2];
}

// 打印日志
2022-11-23 23:02:24.962120+0800 001---RAC初探[11912:536530] 1
2022-11-23 23:02:24.962358+0800 001---RAC初探[11912:536530] 2
信号合并

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

底层实现：
1.当组合信号被订阅，内部会自动订阅signalA，signalB必须两个信号都发出内容，才会被触发。
2.并且把两个信号组合成元组发出。

区别于zipWith zipWith两个信号都要有记录,如果记录的信号触发过了 就不在触发；zipWith记录每一次信号，combineLatestWith记录最后一次的信号。

- (void)testCombineLatest{
    RACSignal *signalA = self.textField.rac_textSignal;
    RACSignal *signalB = [self.button  rac_signalForControlEvents:UIControlEventTouchUpInside];
    
    // 合并信号,任何一个信号发送数据，都能监听到.
    RACSignal *comSignal = [signalA combineLatestWith:signalB];
    [comSignal subscribeNext:^(id x) {
        NSLog(@"%@",x);
    }];
}

// 打印日志
2022-11-22 20:03:13.967697+0800 001---RAC初探[3482:124431] <RACTwoTuple: 0x600003449a20> (
    "",
    "<UIButton: 0x7f8b13f0d380; frame = (166 223; 46 256); opaque = NO; autoresize = RM+BM; layer = <CALayer: 0x60000366c660>>"
)
2022-11-22 20:03:19.526330+0800 001---RAC初探[3482:124431] <RACTwoTuple: 0x6000034509f0> (
    1,
    "<UIButton: 0x7f8b13f0d380; frame = (166 223; 46 256); opaque = NO; autoresize = RM+BM; layer = <CALayer: 0x60000366c660>>"
)

reduce聚合:用于信号发出的内容是元组，把信号发出元组的值聚合成一个值。其中Aggregation(聚合关系)、Composition(合成关系)属于Association(关联关系)，是特殊的Association关联关系。

可以延伸组合关系,聚合关系

  • 组合关系 A-B组合成了C C包含所有的A和B
  • 聚合关系 聚合关系是整体和个体的关系(是强的关联关系) 公司与个人,但是个人不完全属于公司

聚合: 常见的用法，（先组合再聚合）
reduce中的block简介:
reduceblcok中的参数，有多少信号组合，reduceblcok就有多少参数，每个参数就是之前信号发出的内容
reduceblcok的返回值：聚合信号之后的内容。
combineLatest:(id<NSFastEnumeration>)signals reduce:(id (^)())reduceBlock

- (void)testReduce{
    RACSignal *signalA = self.textField.rac_textSignal;
    RACSignal *signalB = [self.button  rac_signalForControlEvents:UIControlEventTouchUpInside];

    // 1.订阅聚合信号，每次有内容发出，就会执行reduceblcok，把信号内容转换成reduceblcok返回的值。
    RACSignal *reduceSignal = [RACSignal combineLatest:@[signalA,signalB] reduce:^(id value1, id value2){
        return [NSString stringWithFormat:@"reduce == %@ %@",value1,value2];
    }];
    
    [reduceSignal subscribeNext:^(id  _Nullable x) {
        NSLog(@"subscribeNext == %@",x);
    }];
}

merge:把多个信号合并成一个信号

- (void)testMerge{
    //创建多个信号
    RACSignal *signalA = self.textField.rac_textSignal;
    RACSignal *signalB = [self.button  rac_signalForControlEvents:UIControlEventTouchUpInside];
    
    // 合并信号,任何一个信号发送数据，都能监听到.
    RACSignal *mergeSignal = [signalA merge:signalB];
    [mergeSignal subscribeNext:^(id x) {
        NSLog(@"x = %@",x);
    }];
}

// 打印日志
2022-11-22 22:23:13.389201+0800 001---RAC初探[5329:216279] x = 111
2022-11-22 22:24:12.004151+0800 001---RAC初探[5329:216279] x = <UIButton: 0x7f7f6be09180; frame = (166 223; 46 256); opaque = NO; autoresize = RM+BM; layer = <CALayer: 0x600002c96700>>

zipWith底层实现:
1.定义压缩信号，内部就会自动订阅signalA，signalB
2.每当signalA或者signalB发出信号，就会判断signalA，signalB有没有发出个信号，有就会把最近发出的信号都包装成元组发出。

- (void)testZip{
    RACSignal *signalA = self.textField.rac_textSignal;
    RACSignal *signalB = [self.button  rac_signalForControlEvents:UIControlEventTouchUpInside];
    
    // 合并信号,任何一个信号发送数据，都能监听到.
    RACSignal *zipSignal = [signalA zipWith:signalB];
    [zipSignal subscribeNext:^(id x) {
        NSLog(@"%@",x);
    }];
}
信号连接
- (void)testContact{
    RACSignal *signalA = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        [subscriber sendNext:@"Hello"];
        [subscriber sendCompleted];
        return nil;
    }];
    
    RACSignal *signalB = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        [subscriber sendNext:@"World"];
        [subscriber sendCompleted];
        return nil;
    }];
    
    RACSignal *contactSignal = [signalA concat:signalB];
    [contactSignal subscribeNext:^(id  _Nullable x) {
        NSLog(@"信号连接%@",x);
    }];
}

// 打印日志
2022-11-22 21:54:00.619302+0800 001---RAC初探[4556:186514] 信号连接Hello
2022-11-22 21:54:00.619527+0800 001---RAC初探[4556:186514] 信号连接World

- (void)testThen{
    [[[RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        [subscriber sendNext:@"Hello"];
        [subscriber sendCompleted];
        return nil;
    }] then:^RACSignal * _Nonnull{
        return [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
            [subscriber sendNext:@"World"];
            [subscriber sendCompleted];
            return nil;
        }];
    }] subscribeNext:^(id  _Nullable x) {
        NSLog(@"%@",x);
    }];
}

// 打印日志
2022-11-22 22:20:31.483147+0800 001---RAC初探[5254:213039] World

使用RAC中bind方法做处理，在返回结果前拼接。
bind方法参数:需要传入一个返回值是RACStreamBindBlock的block参数

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

bind方法使用步骤:
1.传入一个返回值RACStreamBindBlock的block。
2.描述一个RACStreamBindBlock类型的bindBlock作为block的返回值。
3.描述一个返回结果的信号，作为bindBlock的返回值。
注意：在bindBlock中做信号结果的处理。

底层实现:
1.源信号调用bind,会重新创建一个绑定信号。
2.当绑定信号被订阅，就会调用绑定信号中的didSubscribe，生成一个bindingBlock。
3.当源信号有内容发出，就会把内容传递到bindingBlock处理，调用bindingBlock(value,stop)
4.调用bindingBlock(value,stop)，会返回一个内容处理完成的信号（RACReturnSignal）。
5.订阅RACReturnSignal，就会拿到绑定信号的订阅者，把处理完成的信号内容发送出来。
注意:不同订阅者，保存不同的nextBlock，看源码的时候，一定要看清楚订阅者是哪个。这里需要手动导入#import <ReactiveCocoa/RACReturnSignal.h>，才能使用RACReturnSignal。

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

// 打印日志
2022-11-23 23:20:25.583676+0800 001---RAC初探[12013:542540] subscribeNext == 输出:
2022-11-23 23:20:26.994845+0800 001---RAC初探[12013:542540] subscribeNext == 输出:1
信号操作时间
- (void)timeOut{
    RACSignal *signal = [[RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
        return nil;
    }] timeout:1 onScheduler:[RACScheduler currentScheduler]];
    
    [signal subscribeNext:^(id  _Nullable x) {
        NSLog(@"x = %@",x);
    } error:^(NSError * _Nullable error) {
        NSLog(@"error = %@",error);
    }];
}

// 打印日志
2022-11-22 21:58:01.528503+0800 001---RAC初探[4654:190636] error = Error Domain=RACSignalErrorDomain Code=1 "(null)"
信号取值

take:可以屏蔽一些值,取前面几个值---这里take为2 则只拿到前两个值

- (void)take {
    RACSubject *subject = [RACSubject subject];
    [[subject take:2] subscribeNext:^(id x) {
        NSLog(@"%@", x);
    }];
    // 发送信号
    [subject sendNext:@1];
    [subject sendNext:@2];
    [subject sendNext:@3];
}

// 打印日志
2022-11-22 22:01:54.780891+0800 001---RAC初探[4714:193798] 1
2022-11-22 22:01:54.781186+0800 001---RAC初探[4714:193798] 2

takeLast:和take的用法一样，不过他取的是最后的几个值，如下，则取的是最后两个值
注意点:takeLast 一定要调用sendCompleted，告诉他发送完成了，这样才能取到最后的几个值

- (void)takeLast {
    RACSubject *subject = [RACSubject subject];
    [[subject takeLast:2] subscribeNext:^(id x) {
        NSLog(@"%@", x);
    }];
    // 发送信号
    [subject sendNext:@1];
    [subject sendNext:@2];
    [subject sendNext:@3];
    [subject sendCompleted];
}

// 打印日志
2022-11-22 22:03:44.288135+0800 001---RAC初探[4765:195850] 2
2022-11-22 22:03:44.288369+0800 001---RAC初探[4765:195850] 3

takeUntil:---给takeUntil传的是哪个信号，那么当这个信号发送信号或sendCompleted，就不能再接受源信号的内容了。

- (void)takeUntil {
    RACSubject *subject = [RACSubject subject];
    RACSubject *subject2 = [RACSubject subject];
    [[subject takeUntil:subject2] subscribeNext:^(id x) {
        NSLog(@"%@", x);
    }];
    // 发送信号
    [subject sendNext:@1];
    [subject sendNext:@2];
    //    [subject2 sendNext:@3];  // 1
    //    [subject2 sendCompleted]; // 或2
    [subject sendNext:@4];
}

// 打印日志
2022-11-22 22:06:59.819817+0800 001---RAC初探[4868:199064] 1
2022-11-22 22:06:59.820111+0800 001---RAC初探[4868:199064] 2
2022-11-22 22:06:59.820271+0800 001---RAC初探[4868:199064] 4
信号跳过
- (void)testSkip{
    // 表示输入第一次，不会被监听到，跳过第一次发出的信号
    [[self.textField.rac_textSignal skip:1] subscribeNext:^(id x) {
        NSLog(@"%@",x);
    }];
}
获取信号中的信号
- (void)testSwitchToLatest {
    RACSubject *signalOfSignals = [RACSubject subject];
    RACSubject *signal = [RACSubject subject];
    // 获取信号中信号最近发出信号，订阅最近发出的信号。
    // 注意switchToLatest：只能用于信号中的信号
    [signalOfSignals.switchToLatest subscribeNext:^(id x) { NSLog(@"%@",x);
    }];
    [signalOfSignals sendNext:signal];
    [signal sendNext:@1];
}

// 打印日志
2022-11-22 22:10:45.425025+0800 001---RAC初探[4976:203305] 1
信号错误重试

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

- (void)retry{
    //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) {
    
        }];
}

// 打印日志
2022-11-22 22:15:24.167254+0800 001---RAC初探[5075:207315] 接收到错误
2022-11-22 22:15:24.245548+0800 001---RAC初探[5075:207315] 接收到错误
2022-11-22 22:15:24.245849+0800 001---RAC初探[5075:207315] 接收到错误
2022-11-22 22:15:24.246074+0800 001---RAC初探[5075:207315] 接收到错误
2022-11-22 22:15:24.246324+0800 001---RAC初探[5075:207315] 接收到错误
2022-11-22 22:15:24.246580+0800 001---RAC初探[5075:207315] 接收到错误
2022-11-22 22:15:24.246878+0800 001---RAC初探[5075:207315] 接收到错误
2022-11-22 22:15:24.247095+0800 001---RAC初探[5075:207315] 接收到错误
2022-11-22 22:15:24.247306+0800 001---RAC初探[5075:207315] 接收到错误
2022-11-22 22:15:24.247569+0800 001---RAC初探[5075:207315] 接收到错误
2022-11-22 22:15:24.248111+0800 001---RAC初探[5075:207315] 1

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

- (void)replay{
    RACSignal *signal = [[RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
        [subscriber sendNext:@1];
        [subscriber sendNext:@2];
        return nil;
    }] replay];
    [signal subscribeNext:^(id x) {
        NSLog(@"第一个订阅者%@",x);
    }];
    [signal subscribeNext:^(id x) {
        NSLog(@"第二个订阅者%@",x);
    }];
}

// 打印日志
2022-11-22 22:16:58.438272+0800 001---RAC初探[5139:209222] 第一个订阅者1
2022-11-22 22:16:58.438463+0800 001---RAC初探[5139:209222] 第一个订阅者2
2022-11-22 22:16:58.439071+0800 001---RAC初探[5139:209222] 第二个订阅者1
2022-11-22 22:16:58.439237+0800 001---RAC初探[5139:209222] 第二个订阅者2
信号生命周期
信号生命周期

RACSignal使用步骤：

  • 创建信号 + (RACSignal *)createSignal:(RACDisposable * (^)(id<RACSubscriber> subscriber))didSubscribe
  • 订阅信号才会激活信号- (RACDisposable *)subscribeNext:(void (^)(id x))nextBlock
  • 发送信号- (void)sendNext:(id)value 
- (void)racBase{
    // 创建信号
    RACSignal *signal = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        // block调用时刻：每当有订阅者订阅信号，就会调用block。
        [subscriber sendNext:@"Hello World"];
        // 如果不在发送数据，最好发送信号完成，内部会自动调用[RACDisposable disposable]取消订阅信号。
        //        [subscriber sendCompleted];
        NSLog(@"subscriber == %@",subscriber);
        
        RACDisposable *disposable = [RACDisposable disposableWithBlock:^{
            // 销毁信号
            // block调用时刻：当信号发送完成或者发送错误，就会自动执行这个block,取消订阅信号。
            // 执行完Block后，当前信号就不在被订阅了。
            NSLog(@"开始销毁");
        }];
        return disposable;
    }];
    
    // 订阅信号,才会激活信号.
    [signal subscribeNext:^(id  _Nullable x) {
        NSLog(@"x == %@",x);
    }];
}

2022-11-22 20:35:07.838619+0800 001---RAC初探[3821:146953] x == Hello World
2022-11-22 20:35:07.838851+0800 001---RAC初探[3821:146953] subscriber == <RACPassthroughSubscriber: 0x600002d90480>
2022-11-22 20:35:07.839402+0800 001---RAC初探[3821:146953] 开始销毁
RAC信号创建-订阅-发送流程

由于RAC在底层封装了UIControl，就可以在UI中随意使用。

RACSignal底层实现：

  • 创建信号，首先把didSubscribe保存到信号中，还不会触发。
  • 当信号被订阅，也就是调用signal的subscribeNext:nextBlock
    subscribeNext内部会创建订阅者subscriber，并且把nextBlock保存到subscriber中。
    subscribeNext内部会调用siganl的didSubscribe
  • siganl的didSubscribe中调用[subscriber sendNext:@1];
    sendNext底层其实就是执行subscriber的nextBlock
信号销毁
@property (nonatomic, strong) RACDisposable *dispose;

- (void)testTimer{
    self.dispose = [[RACSignal interval:1 onScheduler:[RACScheduler scheduler]] subscribeNext:^(NSDate * _Nullable x) {
        NSLog(@"%@",[NSThread currentThread]);
    }];
}

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
    [self.dispose dispose];
}

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

推荐阅读更多精彩内容

  • RAC简单介绍
    RAC在iOS的实际开发中确实是一件有力的武器，此文将从以下几方面讲解 RACSignal RACSubject ...
    4b5cb36a2ee2阅读 886评论 0赞 0
  • RAC自己练习下
    ReactiveCocoa使用个人总结 ReactiveCocoa简介 ReactiveCocoa（简称RAC）是...
    考槃在涧阅读 258评论 0赞 1
  • RAC使用总结
    RAC使用测试Demo下载：github.com/FuWees/WPRACTestDemo 1.ReactiveC...
    FuWees阅读 6,349评论 3赞 10
  • rac的初步使用
    1、RACSignal // 只要订阅者调用sendNext,就会执行nextBlock // 只要订阅RACD...
    路上捡只猫阅读 845评论 0赞 1
  • iOS-RAC初探
    前言   RAC，全称是ReactiveCocoa，是函数式编程和响应式编程的结合。函数式编程的第一个特点就是可以...
    xxxxxxxx_123阅读 845评论 0赞 1