Reactive Cocoa 学习笔记

作者: TerryZhang | 来源:发表于2016-05-20 13:43 被阅读685次

    Reactive Cocoa 学习笔记

    [TOC]

    基本概念

    什么是RAC

    ReacticeCocoa 结合了好几种编码风格:

    • 函数式编程——利用高阶函数,即函数将其它函数作为其参数
    • 反应性编程——注重于数据流和改变传播

    由于这个原因,你可能会听说过ReactiveCocoa被描述成功能反应性编程(FRC)框架。

    RAC具有函数式编程和响应式编程的特性。

    为什么要学习

    为了提高我们的开发效率。RAC在某些特定情况下开发时可以大大简化代码,并且目前来看安全可靠。

    常用场景

    事件监听

    // 监听了textFild的UIControlEventEditingChanged事件,当事件发生时实现方法NSLog
    [[self.textFild rac_signalForControlEvents:UIControlEventEditingChanged] subscribeNext:^(id x){
        NSLog(@"change");
    }];
    
    // 对于UITextField更简单的写法
    [[self.textFild rac_textSignal] subscribeNext:^(id x) {
        NSLog(@"%@",x);
    }];
    
    // 再比如给我们的某个label添加一个手势动作
    UITapGestureRecognizer *tap = [[UITapGestureRecognizer alloc] init];
    [[tap rac_gestureSignal] subscribeNext:^(id x) {
        NSLog(@"tap");
    }];
    [self.view addGestureRecognizer:tap];
    

    代理

    用RAC写代理是有局限的,它只能实现返回值为void的代理方法

    首先我们要明白我们为什么要用RAC写代理?答:简化代码!
    是的,的确为了简化代码,为什么我要再这里强调这个,是因为在代理方法中我深深的感受到了RAC的优点。一开始我也不愿意花功夫去学RAC,但是我师父给我举了一个例子,,然后再往代理点击事件里加各种方法,代码就又臭又长。那么让我们看看RAC怎么写代理方法。

    // 如果一个View里有多个AlertView,每个AlertView有很多个按钮,每个按钮都有自己的点击事件,不但每个按钮需要打标记,而且每个AlertView也要打标记
    UIAlertView *alertView = [[UIAlertView alloc] initWithTitle:@"RAC" message:@"RAC TEST" delegate:self cancelButtonTitle:@"cancel" otherButtonTitles:@"other", nil];
    [[self rac_signalForSelector:@selector(alertView:clickedButtonAtIndex:) fromProtocol:@protocol(UIAlertViewDelegate)] subscribeNext:^(RACTuple *tuple) {
        //tuple 保存delegate方法中的各个参数
        NSLog(@"%@",tuple.first);
        NSLog(@"%@",tuple.second);
        NSLog(@"%@",tuple.third);
    }];
    [alertView show];
    
    -------------------
    2016-01-04 18:24:29.114 RACStudyTest[5003:388870] <UIAlertView: 0x7ff260c90c70; frame = (0 0; 0 0); layer = <CALayer: 0x7ff260c91030>>
    2016-01-04 18:24:29.115 RACStudyTest[5003:388870] 1
    2016-01-04 18:24:29.115 RACStudyTest[5003:388870] (null)
    --------------
    
    // 简化写法
    [[alertView rac_buttonClickedSignal] subscribeNext:^(id x) {
        NSLog(@"%@",x);
    }];
    
    

    通知

    这句话是不对的‘RAC中的通知不需要remove observer,因为在rac_add方法中他已经写了remove。’

    // 发送通知
    NSMutableArray *dataArray = [[NSMutableArray alloc] initWithObjects:@"1", @"2", @"3", nil];
    [[NSNotificationCenter defaultCenter] postNotificationName:@"postData" object:dataArray];
    
    // 接收通知
    [[[[NSNotificationCenter defaultCenter] 
        rac_addObserverForName:@"postData" object:nil] 
        takeUntil:self.rac_willDeallocSignal]
        subscribeNext:^(NSNotification *notification) {
        NSLog(@"%@", notification.name);
        NSLog(@"%@", notification.object);
    }];
    
    ------------------------------------------------------------------------
    2016-01-04 20:10:52.274 RACStudyTest[5918:439077] postData
    2016-01-04 20:10:52.275 RACStudyTest[5918:439077] (
    1,
    2,
    3
    )
    -----------------------------------------------------------------------
    

    为什么这里要执行takeUntil??

    因为,[[NSNotificationCenter defaultCenter] rac_addObserverForName:UIKeyboardWillHideNotification object:nil]本来是冷信号,订阅以后立即变成热信号。如果不做这一步操作,self即使释放了,订阅的block也是不会释放的。每次通知发出的时候,还是会再次来到这个block去处理。

    KVO

    RAC中得KVO大部分都是宏定义,所以代码异常简洁,简单来说就是RACObserve(TARGET, KEYPATH)这种形式,TARGET是监听目标,KEYPATH是要观察的属性值。

    UIScrollView *scrolView = [[UIScrollView alloc] initWithFrame:CGRectMake(0, 0, 200, 400)];
    scrolView.contentSize = CGSizeMake(200, 800);
    scrolView.backgroundColor = [UIColor greenColor];
    [self.view addSubview:scrolView];
    [RACObserve(scrolView, contentOffset) subscribeNext:^(id x) {
        NSLog(@"success");
    }];
    
    
    // RAC:把一个对象的某个属性绑定一个信号,只要发出信号,就会把信号的内容给对象的属性赋值
    // 给label的text属性绑定了文本框改变的信号
    RAC(self.label, text) = self.textField.rac_textSignal;
    //    [self.textField.rac_textSignal subscribeNext:^(id x) {
    //        self.label.text = x;
    //    }];
    
    

    核心概念

    RACSignal

    信号可以看做是传递信号的工具,当数据变化时,信号就会发送改变的信息,以通知信号的订阅者执行方法。

    热/冷信号

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

    RACSubject是一个有趣的信号类型。在'ReactiveCocoa'的世界中,她是一个可变的状态。她是一个你可以主动发送新值的信号。出于这个原因,除非情况特殊,我们不推荐使用她。

    //创建信号
    RACSignal *signal = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
        [subscriber sendNext:@"signal"];
        [subscriber sendCompleted];
        return nil;
    }];
    
    //订阅信号
    [signal subscribeNext:^(id x) {
        NSLog(@"x = %@", x);
    } error:^(NSError *error) {
        NSLog(@"error = %@", error);
    } completed:^{
        NSLog(@"completed");
    }];
    
    ——————————————
    2016-01-05 14:33:06.106 RACStudyTest[895:38671] x = signal
    2016-01-05 14:33:06.106 RACStudyTest[895:38671] completed
    ——————————————
    

    RACCommand

    • RACCommand:RAC中用于处理事件的类,可以把事件如何处理,事件中的数据如何传递,包装到这个类中,他可以很方便的监控事件的执行过程,比如看事件有没有执行完毕
    • 使用场景:监听按钮点击,网络请求
    // 普通做法
    // RACCommand: 处理事件
    // 不能返回空的信号
    // 1.创建命令
    RACCommand *command = [[RACCommand alloc] initWithSignalBlock:^RACSignal *(id input) {
    //block调用,执行命令的时候就会调用
    NSLog(@"%@",input); // input 为执行命令传进来的参数
    // 这里的返回值不允许为nil
    return [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
    [subscriber sendNext:@"执行命令产生的数据"];
    return nil;
    }];
    }];
    
    // 如何拿到执行命令中产生的数据呢?
    // 订阅命令内部的信号
    // ** 方式一:直接订阅执行命令返回的信号
    
    // 2.执行命令
    RACSignal *signal =[command execute:@2]; // 这里其实用到的是replaySubject 可以先发送命令再订阅
    // 在这里就可以订阅信号了
    [signal subscribeNext:^(id x) {
    NSLog(@"%@",x);
    }];
    
    // 一般做法
    // 1.创建命令
    RACCommand *command = [[RACCommand alloc] initWithSignalBlock:^RACSignal *(id input) {
    //block调用,执行命令的时候就会调用
    NSLog(@"%@",input); // input 为执行命令传进来的参数
    // 这里的返回值不允许为nil
    return [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
    [subscriber sendNext:@"执行命令产生的数据"];
    return nil;
    }];
    }];
    
    // 方式二:
    // 订阅信号
    // 注意:这里必须是先订阅才能发送命令
    // executionSignals:信号源,信号中信号,signalofsignals:信号,发送数据就是信号
    [command.executionSignals subscribeNext:^(RACSignal *x) {
    [x subscribeNext:^(id x) {
    NSLog(@"%@", x);
    }];
    //        NSLog(@"%@", x);
    }];
    
    // 2.执行命令
    [command execute:@2];
    
    
    // 高级做法
    // 1.创建命令
    RACCommand *command = [[RACCommand alloc] initWithSignalBlock:^RACSignal *(id input) {
    // block调用:执行命令的时候就会调用
    NSLog(@"%@", input);
    // 这里的返回值不允许为nil
    return [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
    [subscriber sendNext:@"发送信号"];
    return nil;
    }];
    }];
    
    // 方式三
    // switchToLatest获取最新发送的信号,只能用于信号中信号。
    [command.executionSignals.switchToLatest subscribeNext:^(id x) {
    NSLog(@"%@", x);
    }];
    // 2.执行命令
    [command execute:@3];
    
    
    // switchToLatest--用于信号中信号
    // 创建信号中信号
    RACSubject *signalofsignals = [RACSubject subject];
    RACSubject *signalA = [RACSubject subject];
    // 订阅信号
    //    [signalofsignals subscribeNext:^(RACSignal *x) {
    //        [x subscribeNext:^(id x) {
    //            NSLog(@"%@", x);
    //        }];
    //    }];
    // switchToLatest: 获取信号中信号发送的最新信号
    [signalofsignals.switchToLatest subscribeNext:^(id x) {
    NSLog(@"%@", x);
    }];
    // 发送信号
    [signalofsignals sendNext:signalA];
    [signalA sendNext:@4];
    
    // 监听事件有没有完成
    //注意:当前命令内部发送数据完成,一定要主动发送完成
    // 1.创建命令
    RACCommand *command = [[RACCommand alloc] initWithSignalBlock:^RACSignal *(id input) {
    // block调用:执行命令的时候就会调用
    NSLog(@"%@", input);
    // 这里的返回值不允许为nil
    return [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
    // 发送数据
    [subscriber sendNext:@"执行命令产生的数据"];
    
    // *** 发送完成 **
    [subscriber sendCompleted];
    return nil;
    }];
    }];
    // 监听事件有没有完成
    [command.executing subscribeNext:^(id x) {
    if ([x boolValue] == YES) { // 正在执行
    NSLog(@"当前正在执行%@", x);
    }else {
    // 执行完成/没有执行
    NSLog(@"执行完成/没有执行");
    }
    }];
    
    // 2.执行命令
    [command execute:@1];
    

    RACMulticastConnection

    当有多个订阅者,但是我们只想发送一个信号的时候怎么办?这时我们就可以用RACMulticastConnection,来实现。代码示例如下

    // 普通写法, 这样的缺点是:没订阅一次信号就得重新创建并发送请求,这样很不友好
    RACSignal *signal = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
    // didSubscribeblock中的代码都统称为副作用。
    // 发送请求---比如afn
    NSLog(@"发送请求啦");
    // 发送信号
    [subscriber sendNext:@"ws"];
    return nil;
    }];
    [signal subscribeNext:^(id x) {
    NSLog(@"%@", x);
    }];
    [signal subscribeNext:^(id x) {
    NSLog(@"%@", x);
    }];
    [signal subscribeNext:^(id x) {
    NSLog(@"%@", x);
    }];
    
    
    // 比较好的做法。 使用RACMulticastConnection,无论有多少个订阅者,无论订阅多少次,我只发送一个。
    // 1.发送请求,用一个信号内包装,不管有多少个订阅者,只想发一次请求
    RACSignal *signal = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
    // 发送请求
    NSLog(@"发送请求啦");
    // 发送信号
    [subscriber sendNext:@"ws"];
    return nil;
    }];
    //2. 创建连接类
    RACMulticastConnection *connection = [signal publish];
    [connection.signal subscribeNext:^(id x) {
    NSLog(@"%@", x);
    }];
    [connection.signal subscribeNext:^(id x) {
    NSLog(@"%@", x);
    }];
    [connection.signal subscribeNext:^(id x) {
    NSLog(@"%@", x);
    }];
    //3. 连接。只有连接了才会把信号源变为热信号
    [connection connect];
    
    

    RACSequence

    使用场景---: 可以快速高效的遍历数组和字典。

    NSString *path = [[NSBundle mainBundle] pathForResource:@"flags.plist" ofType:nil];
    NSArray *dictArr = [NSArray arrayWithContentsOfFile:path];
    [dictArr.rac_sequence.signal subscribeNext:^(id x) {
    NSLog(@"%@", x);
    } error:^(NSError *error) {
    NSLog(@"===error===");
    } completed:^{
    NSLog(@"ok---完毕");
    }];
    
    也可以使用宏
    
    NSDictionary *dict = @{@"key":@1, @"key2":@2};
    [dict.rac_sequence.signal subscribeNext:^(id x) {
    NSLog(@"%@", x);
    NSString *key = x[0];
    NSString *value = x[1];
    // RACTupleUnpack宏:专门用来解析元组
    // RACTupleUnpack 等会右边:需要解析的元组 宏的参数,填解析的什么样数据
    // 元组里面有几个值,宏的参数就必须填几个
    RACTupleUnpack(NSString *key, NSString *value) = x;
    NSLog(@"%@ %@", key, value);
    } error:^(NSError *error) {
    NSLog(@"===error");
    } completed:^{
    NSLog(@"-----ok---完毕");
    }];
    

    信号的处理

    信号映射

    map
    [[self.textField.rac_textSignal map:^id(id value) {
        NSLog(@"in map block :%@", value);
        return @1;
    }] subscribeNext:^(id x) {
        NSLog(@"in subscribe block :%@", x);
    }];
    
    //在textField中输入Goods 打印结果如下
    _________________
    (function:__33-[QYKVCKVOViewController setupUI]_block_invoke):in map block :
    (function:__33-[QYKVCKVOViewController setupUI]_block_invoke_2):in subscribe block :1
    (function:__33-[QYKVCKVOViewController setupUI]_block_invoke):in map block :G
    (function:__33-[QYKVCKVOViewController setupUI]_block_invoke_2):in subscribe block :1
    (function:__33-[QYKVCKVOViewController setupUI]_block_invoke):in map block :Go
    (function:__33-[QYKVCKVOViewController setupUI]_block_invoke_2):in subscribe block :1
    (function:__33-[QYKVCKVOViewController setupUI]_block_invoke):in map block :Goo
    (function:__33-[QYKVCKVOViewController setupUI]_block_invoke_2):in subscribe block :1
    (function:__33-[QYKVCKVOViewController setupUI]_block_invoke):in map block :Good
    (function:__33-[QYKVCKVOViewController setupUI]_block_invoke_2):in subscribe block :1
    
    flatmap
    // 创建信号
    RACSubject *subject = [RACSubject subject];
    // 绑定信号
    RACSignal *bindSignal = [subject flattenMap:^RACStream *(id value) {
    // block:只要源信号发送内容就会调用
    // value: 就是源信号发送的内容
    // 返回信号用来包装成修改内容的值
    return [RACReturnSignal return:value];
    
    }];
    
    // flattenMap中返回的是什么信号,订阅的就是什么信号(那么,x的值等于value的值,如果我们操纵value的值那么x也会随之而变)
    // 订阅信号
    [bindSignal subscribeNext:^(id x) {
    NSLog(@"%@", x);
    }];
    
    // 发送数据
    [subject sendNext:@"123"];
    
    }
    
    // flattenMap 主要用于信号中的信号
    // 创建信号
    RACSubject *signalofSignals = [RACSubject subject];
    RACSubject *signal = [RACSubject subject];
    
    // 订阅信号
    //方式1
    //    [signalofSignals subscribeNext:^(id x) {
    //
    //        [x subscribeNext:^(id x) {
    //            NSLog(@"%@", x);
    //        }];
    //    }];
    // 方式2
    //    [signalofSignals.switchToLatest  ];
    // 方式3
    //   RACSignal *bignSignal = [signalofSignals flattenMap:^RACStream *(id value) {
    //
    //        //value:就是源信号发送内容
    //        return value;
    //    }];
    //    [bignSignal subscribeNext:^(id x) {
    //        NSLog(@"%@", x);
    //    }];
    // 方式4--------也是开发中常用的
    [[signalofSignals flattenMap:^RACStream *(id value) {
    return value;
    }] subscribeNext:^(id x) {
    NSLog(@"%@", x);
    }];
    
    // 发送信号
    [signalofSignals sendNext:signal];
    [signal sendNext:@"123"];
    
    

    信号过滤

    filter
    [[self.textFild.rac_textSignal filter:^BOOL(NSString *value) {
        return [value length] > 3;
    }] subscribeNext:^(id x) {
        NSLog(@"x = %@", x);
    }];
    
    // 输入goodnight,输出:
    ——————————————
    2016-01-05 15:18:20.492 RACStudyTest[1490:66721] x = good
    2016-01-05 15:18:27.917 RACStudyTest[1490:66721] x = goodn
    2016-01-05 15:18:28.129 RACStudyTest[1490:66721] x = goodni
    2016-01-05 15:18:28.433 RACStudyTest[1490:66721] x = goodnig
    2016-01-05 15:18:28.930 RACStudyTest[1490:66721] x = goodnigh
    2016-01-05 15:18:29.155 RACStudyTest[1490:66721] x = goodnight
    
    
    take/skip/repeat

    take是获取,skip是跳过,这两个方法后面跟着的都是NSInteger。
    所以take 2就是获取前两个信号,skip 2就是跳过前两个。
    repeat是重复发送信号。

    相似的还有takeLasttakeUntiltakeWhileBlockskipWhileBlockskipUntilBlockrepeatWhileBlock都可以根据字面意思来理解。

    // 这个demo只会输出前两个信号1和2还有完成信号completed,skip,repeat同理。
    RACSignal *signal = [[RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
        [subscriber sendNext:@"1"];
        [subscriber sendNext:@"2"];
        [subscriber sendNext:@"3"];
        [subscriber sendNext:@"4"];
        [subscriber sendNext:@"5"];
        [subscriber sendCompleted];
        return nil;
    }] take:2];
    
    [signal subscribeNext:^(id x) {
        NSLog(@"%@", x);
    }completed:^{
        NSLog(@"completed");
    }];
    
    
    // takeUntil:---给takeUntil传的是哪个信号,那么当这个信号发送信号或sendCompleted,就不能再接受源信号的内容了。
    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];
    
    throttle

    节流,在我们做搜索框的时候,有时候需求的时实时搜索,即用户每每输入字符,view都要求展现搜索结果。这时如果用户搜索的字符串较长,那么由于网络请求的延时可能造成UI显示错误,并且多次不必要的请求还会加大服务器的压力,这显然是不合理的,此时我们就需要用到节流。

    [[[self.textFild rac_textSignal] throttle:0.5] subscribeNext:^(id x) {
        NSLog(@"%@", x);
    }];
    
    

    加了节流管道,后面跟上了类型为NSTimeInterval的参数后,只有0.5S内信号不产生变化才会发送请求,这样快速的输入也不会造成多次输出。

    distinctUntilChanged

    网络请求中为了减轻服务器压力,无用的请求我们应该尽可能不发送。distinctUntilChanged的作用是使RAC不会连续发送两次相同的信号,这样就解决了这个问题。

    [[[self.textFild rac_textSignal] distinctUntilChanged] subscribeNext:^(id x) {
        NSLog(@"%@", x);
    }];
    
    
    ignore

    忽略信号,指定一个任意类型的量(可以是字符串,数组等),当需要发送信号时讲进行判断,若相同则该信号会被忽略发送。

    [[[self.textFild rac_textSignal] ignore:@"good"] subscribeNext:^(id x) {
        NSLog(@"%@", x);
    }];
    

    信号组合

    combineLatest:reduce

    使用一个 signals 信号的数组;
    在任意signal变化时,使用他们的最后一次的值来执行block;
    并返回一个新的 RACSignal信号对象来将block的值用作属性的新值来发送;
    简单说,类似于重写createEnabled 属性的 getter 方法.

    // 思路--- 就是把输入框输入值的信号都聚合成按钮是否能点击的信号。
    // combineLatest 将两个信号聚合成一个信号
    RACSignal *combinSignal = [RACSignal combineLatest:@[self.accountField.rac_textSignal, self.pwdField.rac_textSignal]
    reduce:^id(NSString *account, NSString *pwd){ //reduce里的参数一定要和combineLatest数组里的一一对应。
    // block: 只要源信号发送内容,就会调用,组合成一个新值。
    NSLog(@"%@ %@", account, pwd);
    return @(account.length && pwd.length);
    }];
    
    //    // 订阅信号
    //    [combinSignal subscribeNext:^(id x) {
    //        self.loginBtn.enabled = [x boolValue];
    //    }];    // ----这样写有些麻烦,可以直接用RAC宏
    RAC(self.loginBtn, enabled) = combinSignal;
    
    
    zipWith

    zipWith:把两个信号压缩成一个信号,只有当两个信号同时发出信号内容时,并且把两个信号的内容合并成一个元祖,才会触发压缩流的next事件。

    // 创建信号A
    RACSubject *signalA = [RACSubject subject];
    // 创建信号B
    RACSubject *signalB = [RACSubject subject];
    // 压缩成一个信号
    // **-zipWith-**: 当一个界面多个请求的时候,要等所有请求完成才更新UI
    // 等所有信号都发送内容的时候才会调用
    RACSignal *zipSignal = [signalA zipWith:signalB];
    [zipSignal subscribeNext:^(id x) {
    NSLog(@"%@", x); //所有的值都被包装成了元组
    }];
    
    // 发送信号 交互顺序,元组内元素的顺序不会变,跟发送的顺序无关,而是跟压缩的顺序有关[signalA zipWith:signalB]---先是A后是B
    [signalA sendNext:@1];
    [signalB sendNext:@2];
    
    
    merge

    merge:多个信号合并成一个信号,任何一个信号有新值就会调用

    // 任何一个信号请求完成都会被订阅到
    // 创建信号A
    RACSubject *signalA = [RACSubject subject];
    // 创建信号B
    RACSubject *signalB = [RACSubject subject];
    //组合信号
    RACSignal *mergeSignal = [signalA merge:signalB];
    // 订阅信号
    [mergeSignal subscribeNext:^(id x) {
    NSLog(@"%@", x);
    }];
    // 发送信号---交换位置则数据结果顺序也会交换
    [signalB sendNext:@"下部分"];
    [signalA sendNext:@"上部分"];
    }
    
    then
    // 创建信号A
    RACSignal *signalA = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
    // 发送请求
    NSLog(@"----发送上部分请求---afn");
    
    [subscriber sendNext:@"上部分数据"];
    [subscriber sendCompleted]; // 必须要调用sendCompleted方法!
    return nil;
    }];
    
    // 创建信号B,
    RACSignal *signalsB = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
    // 发送请求
    NSLog(@"--发送下部分请求--afn");
    [subscriber sendNext:@"下部分数据"];
    return nil;
    }];
    // 创建组合信号
    // then;忽略掉第一个信号的所有值
    RACSignal *thenSignal = [signalA then:^RACSignal *{
    // 返回的信号就是要组合的信号
    return signalsB;
    }];
    
    // 订阅信号
    [thenSignal subscribeNext:^(id x) {
    NSLog(@"%@", x);
    }];
    
    concat

    // concat----- 使用需求:有两部分数据:想让上部分先执行,完了之后再让下部分执行(都可获取值)

    
    // 创建信号A
    RACSignal *signalA = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
    // 发送请求
    //        NSLog(@"----发送上部分请求---afn");
        [subscriber sendNext:@"上部分数据"];
        [subscriber sendCompleted]; // 必须要调用sendCompleted方法!
        return nil;
    }];
    
    // 创建信号B,
    RACSignal *signalsB = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
    // 发送请求
    //        NSLog(@"--发送下部分请求--afn");
        [subscriber sendNext:@"下部分数据"];
        return nil;
    }];
    
    
    // concat:按顺序去链接
    //**-注意-**:concat,第一个信号必须要调用sendCompleted
    // 创建组合信号
    RACSignal *concatSignal = [signalA concat:signalsB];
    // 订阅组合信号
    [concatSignal subscribeNext:^(id x) {
    NSLog(@"%@",x);
    }];
    

    其他操作

    delay

    延时信号,顾名思义,即延迟发送信号。

    RACSignal *signal = [[RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
        [subscriber sendNext:@"delay"];
        [subscriber sendCompleted];
        return nil;
    }] delay:2];
    
    NSLog(@"tag");
    
    [signal subscribeNext:^(id x) {
        NSLog(@"%@", x);
    }];
    
    _________________
    2016-01-05 15:27:55.908 RACStudyTest[1543:71256] tag
    2016-01-05 15:27:58.102 RACStudyTest[1543:71256] delay
    //还有0.2s误差是因为运行到不同代码行的时间差
    
    timeout

    超时信号,当超出限定时间后会给订阅者发送error信号。

    RACSignal *signal = [[RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
        [[RACScheduler mainThreadScheduler] afterDelay:3 schedule:^{
            [subscriber sendNext:@"delay"];
            [subscriber sendCompleted];
        }];
        return nil;
    }] timeout:2 onScheduler:[RACScheduler mainThreadScheduler]];
    
    [signal subscribeNext:^(id x) {
        NSLog(@"%@", x);
    } error:^(NSError *error) {
        NSLog(@"%@", error);
    }];
    
    //由于在创建信号是限定了延迟3秒发送,但是加了timeout2秒的限定,所以这一定是一个超时信号。这个信号被订阅后,由于超时,不会执行订阅成功的输出x方法,而是跳到error的块输出了错误信息。timeout在用RAC封装网络请求时可以节省不少的代码量。
    _________________
    2016-01-05 15:41:58.686 RACStudyTest[1604:76716] Error Domain=RACSignalErrorDomain Code=1 "The operation couldn’t be completed. (RACSignalErrorDomain error 1.)"
    
    

    点评场景

    whiteBoard

    //TODO

    - (void)setupModule
    {
        [self setupTitleCell];
        [self setupPickDateCell];
        @weakify(self)
        [NVWBObserve(self, product) subscribeNext:^(NVModelBaseZeusProduct *product)
         {
             @strongify(self);
             self.packageList = product.zeusSpuPackageList;
         }];
    
    }
    

    网络请求

    - (void)queryZeusDetailInfo
    {
        mparam_zeusproductdetail_travel *params = [mparam_zeusproductdetail_travel new];
        params.spuid = @(_spuid);
        params.cityid = @([NVLocateHelper sharedInstance].city.uid);
        @weakify(self);
        [[[NVNetworkClient client] mapi_zeusproductdetail_travel_withParameters:params cachePolicy:NVCacheTypeDisabled] subscribeNext:^(NVModelBaseZeusProductDetail *productDetail) {
            @strongify(self);
            self.productDetail = productDetail;
            [self needReloadTableView];
    
        } error:^(NSError *error) {
        }];
    }
    

    高级进阶

    热/冷信号

    //TODO

    实现原理

    //TODO

    参考链接

    相关文章

      网友评论

      • Zero_D_Saber:通知也得需要移除,需要在信号后面加上takeUntil: self.rac_willDeallocSignal方法,否则会出现内存泄露。
        Dimon_Hu:@Zero_D_Saber 好厉害

      本文标题:Reactive Cocoa 学习笔记

      本文链接:https://www.haomeiwen.com/subject/rprnrttx.html