前言

不同于前面的几篇文章,在这个系列里,我会通过我以前的学习介绍一些常用的基本API的作用,集团的项目写的比较快,所以我想着在不影响项目的进度下对新项目使用新技术,希望大家在开发的过程中,都能够增长自己的见识.

RAC的常用操作

RACSignal的创建

• 单元信号的创建
  我目前的使用频率不是很高,这里只是列出来
  //发送某个值,通过next可以订阅到
  RACSignal *signal1 = [RACSignal return:@1];
  //发送某个错误,通过error可以订阅到
  RACSignal *signal2 = [RACSignal error:[NSError errorWithDomain:@"com.vcredit" code:100 userInfo:@{@"error":@"错误"}]];
  //发送某个空信号,发送即完成,可以通过订阅完成信号订阅到
  RACSignal *signal3 = [RACSignal empty];
  //订阅不到该信号
  RACSignal *signal4 = [RACSignal never];

• 动态信号的创建
  使用频率很高的一种创建方式
  RACSignal *signal5 = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
  [subscriber sendNext:@1];
  //发送了错误信号完成信号就无法订阅到了
  [subscriber sendError: [NSError errorWithDomain:@"com.vcredit" code:100 userInfo:@{@"error":@"错误"}]];
  [subscriber sendCompleted];
  return [RACDisposable disposableWithBlock:^{
  }];
  }];

• 与原生的桥接
  一般都是与UI事件搭配起来使用,具体的请查看rac的分类
  RACSignal *signal6 = [button rac_signalForSelector:@selector(setBackground:)];
  RACSignal *signal7 = [button rac_signalForControlEvents:UIControlEventTouchUpInside];
  RACSignal *signal8 = [button rac_willDeallocSignal];
  RACSignal *signal9 = [textField rac_textSignal];

• 代理
  用来替代无返回值的代理,详情查看RAC常用的六个用法
  //这里订阅收到的是一个x,当一个页面存在多个tableview时,我们可以对x进行判断看是哪个tableview
  [[self rac_signalForSelector:@selector(tableView:didSelectRowAtIndexPath:) fromProtocol:@protocol(UITableViewDelegate) ] subscribeNext:^(RACTuple * x) {
  NSLog(@"%@,%@",x.first,x.second);
  }];
  tableview.delegate = self;

• 代替KVO
  [RACObserve(scrollView, contentOffset) subscribeNext:^(id x) {
  NSLog(@"%@",x);
  }];

• 代替通知
  RACSignal * deallocSignal = [self rac_signalForSelector:@selector(viewWillDisappear:)];
  [[[[NSNotificationCenter defaultCenter] rac_addObserverForName:@"haha" object:nil] takeUntil:deallocSignal] subscribeNext:^(id x) {
  NSLog(@"haha");
  }];

• 时间信号
  //创建延迟信号,五秒后执行一次
  [[RACScheduler mainThreadScheduler]afterDelay:5 schedule:^{
  NSLog(@"五秒后执行一次");
  }];
  //创建定时信号
  //每隔两秒执行一次,这里要加takeUntil条件限制一下否则当控制器pop后依旧会执行
  [[[RACSignal interval:2 onScheduler:[RACScheduler mainThreadScheduler]] takeUntil:self.rac_willDeallocSignal ] subscribeNext:^(id x) {
  NSLog(@"每两秒执行一次");
  }];

RACSignal的订阅

• 完整订阅
  //值,error,完成信号的全部订阅,可以根据场景选择自己要订阅什么,执行相应的api
  RACDisposable *disposeable = [signal10 subscribeNext:^(id x) {

            NSLog(@"%@",x);
        } error:^(NSError *error) {
            NSLog(@"%@",error);
        } completed:^{
            NSLog(@"完成了");
        }];  
        //使用完可以手动dispose,结束订阅
        [disposeable dispose];

• RAC宏绑定
  //单向绑定,signal10中的next值将作用于view的背景色
  RAC(self.view,backgroundColor) = signal10;
  //双向绑定,互相作用
  RACChannelTo(self.lb_name,text) = RACChannelTo(model, name);

• 与Cocoa进行桥接的订阅
  //信号不能为空,且参数需对应
  [self.view rac_liftSelector:@selector(setBackgroundImage:forState:) withSignals:signal10,signal11, nil];
  [self.view rac_liftSelector:@selector(setBackgroundImage:forState:) withSignalsFromArray:@[signal10,signal11]];

RACSignal的操作

• 对值得操作(Map)
  例如当我们需要对时间戳进行转换返回我们想要的信号时
  RACSignal *signal11 = [RACSignal return:@1];
  //对信号11进行加工,对信号12进行订阅时能够得到返回两倍的值
  RACSignal *signal12 = [signal11 map:^id(NSNumber * value) {
  return @(value.integerValue *2);
  }];
  //将信号11的next值全部置为一个对象
  RACSignal *signal13 = [signal11 mapReplace:@2];

        RACSignal *signal14 = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
            //RACTuple是一个元祖,他在OC中类似一个数组,他的侧重点在于存储不同类型的数据
            RACTuple *tuple1 = RACTuplePack(@"张三",@14);
            RACTuple *tuple2 = RACTuplePack(@"李四",@15);
            [subscriber sendNext:tuple1];
            [subscriber sendNext:tuple2];
            [subscriber sendCompleted];
            return [RACDisposable disposableWithBlock:^{                  
            }];
        }];
        RACSignal *signal15 =[signal14 reduceEach:^id(NSString *name, NSNumber *age){
            return [NSString stringWithFormat:@"我叫%@,今年%ld岁",name,age.integerValue];
        }];

• 对数量操作
  过滤(filter)
  RACSignal *signal16 = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
  [subscriber sendNext:@"abv"];
  [subscriber sendNext:@"haha"];
  [subscriber sendNext:@"1"];
  [subscriber sendNext:@"dota2"];
  [subscriber sendCompleted];
  return [RACDisposable disposableWithBlock:^{
  }];
  }];
  //将signal16发出的next值,字符串长度大于2的取出再次sendnext
  RACSignal *signal17 = [signal16 filter:^BOOL(NSString * value) {
  return value.length > 2;
  }];
  忽略(ignore)
  //忽略掉了字符串1,可以链式调用
  RACSignal *signal18 = [signal16 ignore:@"1"];
  //忽略所有值
  RACSignal *signal19 = [signal16 ignoreValues];
  //忽略所有相同值,不同值才会sendnext
  RACSignal *signal20 = [signal16 distinctUntilChanged];
  截取(take)
  //截取前两个
  RACSignal *signal21 = [signal16 take:2];
  //截取后两个
  RACSignal *signal23 = [signal16 takeLast:2];
  //当信号23发出信号后,我们就无法在订阅到信号22的内容了
  [signal22 takeUntil:signal23];
  跳过(skip)
  //跳过一个next值
  RACSignal *signal22 = [signal16 skip:1];
  添加开始next值(start)
  //在发送next开始前,先发送这个start对象
  RACSignal *signal24 = [signal16 startWith:@"开始"];
  死循环重复(repeat)
  //不断重复的发送信号16中的值,这里需要对发送频率作出限制或者即时取消,否则会导致CPU占用过高.
  RACSignal *signal25 = [signal16 repeat];
  失败重复(Retry)
  //当信号16发送error信号时,我们可以再次执行两次,若依然发送error,则信号26发送error
  RACSignal *signal26 = [signal16 retry:2];
  //当信号16发送error信号时,我们可以再次执行,知道发送完成信号
  RACSignal *signal27 = [signal16 retry];
  连接next返回一个数组(Collect)
  //连接信号16中的所有next值,最后用数组返回回来
  RACSignal *signal29 = [signal16 collect];
  折叠操作,类似递归(aggregate),只关注结果,不关注过程
  //类似一个递归的过程
  RACSignal *signal30 = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
  [subscriber sendNext:@1];
  [subscriber sendNext:@2];
  [subscriber sendNext:@3];
  [subscriber sendCompleted];
  return nil;
  }];
  RACSignal *signal31 = [signal30 aggregateWithStart:@0 reduce:^id(NSNumber * running, NSNumber * next) {
  return @(running.integerValue + next.integerValue);
  }];
  扫描操作(scan),递归的过程也是有值得
  //每一次递归完成,也会send一个next值
  RACSignal *signal32 = [signal30 scanWithStart:@0 reduce:^id(NSNumber * running, NSNumber * next) {
  return @(running.integerValue + next.integerValue);
  }];

• 副作用操作
  doNext ,doError
  RACSignal *signal28 = [signal16 doNext:^(id x) {
  //改变外界变量的副作用最好写在这里,提示阅读者这部分是副作用
  }];

• 时间操作
  节流(throttle),常用在即时搜索的优化
  //若两秒内都有next值发出,那么取最后一次发出的next值发送
  RACSignal *signal33 = [signal16 throttle:2];

• 组合操作
  连接信号的next值(Concat),这里被链接的信号一定要发送完成信号,否则连接的信号始终不会被连接上
  //信号34发送的next信号就是信号33发送完next后,再次发送完成信号后开始拼接信号16
  RACSignal *signal34 = [signal33 concat:signal16];
  混合操作(Merge),连接两个信号,根据信号的时间顺序进行组合,可能会按照时间的先后二者的next值进行交叉,完成信号以最晚发出完成信号的为准
  //按照时间顺序将信号33与信号34进行交叉排列
  RACSignal *signal35 = [signal33 merge:signal34];
  压缩操作,只以next配对(zip),将两个信号上的next按时间顺序配对排列,注意必须要成对,若信号不成对则不会在新信号中输出next值,当二者都发送了完成信号时,新信号发送完成信号
  //压缩需成对,否则不会在新信号中发出,
  RACSignal *signal36 = [signal34 zipWith:signal35];
  压缩操作,以时间配对(combineLatestWith)
  //压缩成对,这里与zip不同,signal37的next值会在当信号34和信号35没发出一个next值都会将二者的最新信号进行配对
  RACSignal *signal37 = [signal34 combineLatestWith:signal35];

根据信号B发送next时获取当前信号A上的值,当信号A完成时,新信号也完成
//例如信号35是个按钮点击信号,每点击一次,都会获取信号34上最新的值,包括error信号
RACSignal *signal38 = [signal34 combineLatestWith:signal35];
根据信号B的next值发送一个截取信号,截断此时信号A以后的发送,同时将B发出的信号拼接到后面,组成新信号
//当信号35发出信号时,信号34之后的信号不会加入新信号,同时将信号35拼接到新信号后面
RACSignal *signal39 =[signal34 takeUntilReplacement:signal35];

RAC的高级操作

RAC高阶操作

• 信号的升阶(讲一个信号变为信号的信号)
  //将信号包裹起来发送出去
  RACSignal *signal40 = [RACSignal return:@1];
  RACSignal *highSignal1 = [RACSignal return:signal40];
  RACSignal *highSignal2 = [signal40 map:^id(id value) {
  return [RACSignal return:value];
  }];

• 订阅高阶信号(降阶操作,订阅到信号中的信号)
  首先是一种最容易理解的做法,但我们一般不这么使用.
  //将信号中的信号取出,然后对这个信号进行订阅,但一般没人这么干
  [highSignal1 subscribeNext:^(RACSignal *normalSignal) {
  [normalSignal subscribeNext:^(id x) {}];}];
  取出高阶信号中最新的值(switchToLatest),旧的值可能会因为新值的出现而取不到,所有的降阶信号如果遇到error则停止取出原来高阶信号后面新的信号(若果这不是我们的预期可以通过catch来解决),直接发送error信号
  [highSignal1.switchToLatest subscribeNext:^(id x) { }];
  取出所有信号,并将它们按顺序排列(Flatten)
  [highSignal1.flatten subscribeNext:^(id x) {}];
  //控制信号扁平化中最大的一个数量,多用于控制线程的并发数,同时处理信号有个数限制,只有处理完了当前的信号,才会将别的信号纳入处理
  [[highSignal1 flatten:2] subscribeNext:^(id x) {}];
  对信号进行操作的有利武器(flattenMap)
  //将高阶信号降阶
  RACSignal *normalSignal = [signalOfSignal flattenMap:^RACStream *(RACSignal * value) {
  return value;
  }];
  //将低阶信号升阶
  [signalOfSignal flattenMap:^RACStream *(id value) {
  return [RACSignal return:value];
  }];

冷信号与热信号

• 冷信号转热信号
  //冷信号->热信号
  RACSignal *coldSignal = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
  [subscriber sendNext:@1];
  [subscriber sendNext:@2];
  [subscriber sendNext:@3];
  [subscriber sendCompleted];
  return nil;
  }];
  RACSubject *subject = [RACSubject subject];
  [coldSignal subscribe:subject];
  [subject subscribeNext:^(id x) {}];
  官方推荐的几个方法

• 1publish(- (RACMulticastConnection *)publish)(- (RACMulticastConnection *)multicast:(RACSubject *)subject)(- (RACSignal *)replay)
  //连接完成后才会变成热信号
  RACMulticastConnection *connection = [coldSignal publish];
  [connection.signal subscribeNext:^(id x) {}];
  [connection connect];

RAC并发

RAC整个是一个异步库,他有自己实现并发的方式,它是基于GCD的,与GCD相比,它具有伪取消,与其他RAC组件高度整合,一个RACScheduler内的任务是顺序执行的,一个RACScheduler并不保证是一个线程.这里我还是觉得GCD或者NSOperation好用一些,也可以说我暂时还是对RACScheduler还不是很熟练吧.

• RACScheduler的创建
  //创建主线程
  RACScheduler *mainScheduler = [RACScheduler mainThreadScheduler];
  //创建子线程
  RACScheduler *scheduler = [RACScheduler scheduler];
  //返回当前线程
  RACScheduler *currentScheduler = [RACScheduler currentScheduler];
  //创建优先级scheduler
  RACScheduler *priority = [RACScheduler schedulerWithPriority:RACSchedulerPriorityHigh];

• RACScheduler执行任务
  //分派一个任务,在主线程执行
  [mainScheduler schedule:^{}];
  //定时在指定线程执行任务
  NSDate *nowDate = [NSDate date];
  [scheduler after:nowDate schedule:^{}];
  //延时任务
  [scheduler afterDelay:30 schedule:^{}];
  //循环任务,从现在开始每1秒执行一次,最长不能超过1.1秒执行下一次
  [scheduler after:nowDate repeatingEvery:1 withLeeway:0.1 schedule:^{}];

• 指定RACScheduler订阅和发送
  主要需要注意的地方就是,UI绘制只能在主线程
  //主线程订阅(订阅时机不确定),block内容放到指定线程执行,不能保证传递值在哪个线程执行
  [[signal subscribeOn:[RACScheduler mainThreadScheduler]] subscribeNext:^(id x) {}];
  //主线程订阅(发送时机不确定),内容传递切换到指定线程,而block内依然在原线程执行
  [[signal deliverOn:[RACScheduler mainThreadScheduler]] subscribeNext:^(id x) {}];