iOS reactiveCocoa

一些常用的语法总结

github地址: lc_reactiveCocoa

     

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
/**
 学习框架首要之处:个人认为先要搞清楚框架中常用的类,在RAC中最核心的类RACSiganl,搞定这个类就能用ReactiveCocoa开发了。
  
 ***/
 
 
 
#pragma mark - RACSiganl
 
/** RACSiganl:信号类,一般表示将来有数据传递,只要有数据改变,信号内部接收到数据,就会马上发出数据。
  
 信号类(RACSiganl),只是表示当数据改变时,信号内部会发出数据,它本身不具备发送信号的能力,而是交给内部一个订阅者去发出。
  
 默认一个信号都是冷信号,也就是值改变了,也不会触发,只有订阅了这个信号,这个信号才会变为热信号,值改变了才会触发。
  
 如何订阅信号:调用信号RACSignal的subscribeNext就能订阅。
 **/
 
- (void)lc_RACSiganl {
    // RACSignal底层实现:
    // 1.创建信号,首先把didSubscribe保存到信号中,还不会触发。
    // 2.当信号被订阅,也就是调用signal的subscribeNext:nextBlock
    // 2.2 subscribeNext内部会创建订阅者subscriber,并且把nextBlock保存到subscriber中。
    // 2.1 subscribeNext内部会调用siganl的didSubscribe
    // 3.siganl的didSubscribe中调用[subscriber sendNext:@1];
    // 3.1 sendNext底层其实就是执行subscriber的nextBlock
     
    // 1.创建信号
    RACSignal *siganl = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
         
        // block调用时刻:每当有订阅者订阅信号,就会调用block。
         
        // 2.发送信号
        [subscriber sendNext:@1];
         
        // 如果不在发送数据,最好发送信号完成,内部会自动调用[RACDisposable disposable]取消订阅信号。
        [subscriber sendCompleted];
         
        return [RACDisposable disposableWithBlock:^{
             
            // block调用时刻:当信号发送完成或者发送错误,就会自动执行这个block,取消订阅信号。
             
            // 执行完Block后,当前信号就不在被订阅了。
             
            NSLog(@"信号被销毁");
             
        }];
    }];
     
    // 3.订阅信号,才会激活信号.
    [siganl subscribeNext:^(id x) {
        // block调用时刻:每当有信号发出数据,就会调用block.
        NSLog(@"接收到数据:%@",x);
    }];
}
 
 
 
#pragma mark - RACReplaySubject
/** RACReplaySubject:重复提供信号类,RACSubject的子类。
  
 RACReplaySubject与RACSubject区别:
 RACReplaySubject可以先发送信号,在订阅信号,RACSubject就不可以。
 使用场景一:如果一个信号每被订阅一次,就需要把之前的值重复发送一遍,使用重复提供信号类。
  
 使用场景二:可以设置capacity数量来限制缓存的value的数量,即只缓充最新的几个值。
 **/
 
- (void)lc_RACReplaySubject {
    // RACSubject使用步骤
    // 1.创建信号 [RACSubject subject],跟RACSiganl不一样,创建信号时没有block。
    // 2.订阅信号 - (RACDisposable *)subscribeNext:(void (^)(id x))nextBlock
    // 3.发送信号 sendNext:(id)value
     
    // RACSubject:底层实现和RACSignal不一样。
    // 1.调用subscribeNext订阅信号,只是把订阅者保存起来,并且订阅者的nextBlock已经赋值了。
    // 2.调用sendNext发送信号,遍历刚刚保存的所有订阅者,一个一个调用订阅者的nextBlock。
     
    // 1.创建信号
    RACSubject *subject = [RACSubject subject];
     
    // 2.订阅信号
    [subject subscribeNext:^(id x) {
        // block调用时刻:当信号发出新值,就会调用.
        NSLog(@"第一个订阅者%@",x);
    }];
    [subject subscribeNext:^(id x) {
        // block调用时刻:当信号发出新值,就会调用.
        NSLog(@"第二个订阅者%@",x);
    }];
     
    // 3.发送信号
    [subject sendNext:@"1"];
    [subject sendNext:@"2"];
     
     
    // RACReplaySubject使用步骤:
    // 1.创建信号 [RACSubject subject],跟RACSiganl不一样,创建信号时没有block。
    // 2.可以先订阅信号,也可以先发送信号。
    // 2.1 订阅信号 - (RACDisposable *)subscribeNext:(void (^)(id x))nextBlock
    // 2.2 发送信号 sendNext:(id)value
     
    // RACReplaySubject:底层实现和RACSubject不一样。
    // 1.调用sendNext发送信号,把值保存起来,然后遍历刚刚保存的所有订阅者,一个一个调用订阅者的nextBlock。
    // 2.调用subscribeNext订阅信号,遍历保存的所有值,一个一个调用订阅者的nextBlock
     
    // 如果想当一个信号被订阅,就重复播放之前所有值,需要先发送信号,在订阅信号。
    // 也就是先保存值,在订阅值。
     
    // 1.创建信号
    RACReplaySubject *replaySubject = [RACReplaySubject subject];
     
    // 2.发送信号
    [replaySubject sendNext:@1];
    [replaySubject sendNext:@2];
     
    // 3.订阅信号
    [replaySubject subscribeNext:^(id x) {
         
        NSLog(@"第一个订阅者接收到的数据%@",x);
    }];
     
    // 订阅信号
    [replaySubject subscribeNext:^(id x) {
         
        NSLog(@"第二个订阅者接收到的数据%@",x);
    }];
}
 
#pragma mark - RACMulticastConnection
/** RACMulticastConnection:用于当一个信号,被多次订阅时,为了保证创建信号时,避免多次调用创建信号中的block,造成副作用,可以使用这个类处理。
  
 使用注意:RACMulticastConnection通过RACSignal的-publish或者-muticast:方法创建.
 **/
 
- (void)lc_RACMulticastConnection {
    // RACMulticastConnection使用步骤:
    // 1.创建信号 + (RACSignal *)createSignal:(RACDisposable * (^)(id<RACSubscriber> subscriber))didSubscribe
    // 2.创建连接 RACMulticastConnection *connect = [signal publish];
    // 3.订阅信号,注意:订阅的不在是之前的信号,而是连接的信号。 [connect.signal subscribeNext:nextBlock]
    // 4.连接 [connect connect]
     
    // RACMulticastConnection底层原理:
    // 1.创建connect,connect.sourceSignal -> RACSignal(原始信号)  connect.signal -> RACSubject
    // 2.订阅connect.signal,会调用RACSubject的subscribeNext,创建订阅者,而且把订阅者保存起来,不会执行block。
    // 3.[connect connect]内部会订阅RACSignal(原始信号),并且订阅者是RACSubject
    // 3.1.订阅原始信号,就会调用原始信号中的didSubscribe
    // 3.2 didSubscribe,拿到订阅者调用sendNext,其实是调用RACSubject的sendNext
    // 4.RACSubject的sendNext,会遍历RACSubject所有订阅者发送信号。
    // 4.1 因为刚刚第二步,都是在订阅RACSubject,因此会拿到第二步所有的订阅者,调用他们的nextBlock
     
     
    // 需求:假设在一个信号中发送请求,每次订阅一次都会发送请求,这样就会导致多次请求。
    // 解决:使用RACMulticastConnection就能解决.
     
#if 0
    // 1.创建请求信号
    RACSignal *signal = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
         
         
        NSLog(@"发送请求");
         
        return nil;
    }];
    // 2.订阅信号
    [signal subscribeNext:^(id x) {
         
        NSLog(@"接收数据");
         
    }];
    // 2.订阅信号
    [signal subscribeNext:^(id x) {
         
        NSLog(@"接收数据");
         
    }];
     
    // 3.运行结果,会执行两遍发送请求,也就是每次订阅都会发送一次请求
     
#else
    // RACMulticastConnection:解决重复请求问题
    // 1.创建信号
    RACSignal *signal = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
         
         
        NSLog(@"发送请求");
        [subscriber sendNext:@1];
         
        return nil;
    }];
     
    // 2.创建连接
    RACMulticastConnection *connect = [signal publish];
     
    // 3.订阅信号,
    // 注意:订阅信号,也不能激活信号,只是保存订阅者到数组,必须通过连接,当调用连接,就会一次性调用所有订阅者的sendNext:
    [connect.signal subscribeNext:^(id x) {
         
        NSLog(@"订阅者一信号");
         
    }];
     
    [connect.signal subscribeNext:^(id x) {
         
        NSLog(@"订阅者二信号");
         
    }];
     
    // 4.连接,激活信号
    [connect connect];
#endif
     
}
 
#pragma mark - lc_throttle
- (void)lc_throttle {
    UITextField * tf_search = [[UITextField alloc]init];
     
    //这段代码的意思是若0.3秒内无新信号(tf无输入),并且输入框内不为空那么将会执行,这对服务器的压力减少有巨大帮助同时提高了用户体验
    [[[[[[tf_search.rac_textSignal throttle:0.3]distinctUntilChanged]ignore:@""] map:^id(id value) {
         
        //这里使用的是信号中的信号这个概念
        return [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
             
            //  network request
             
            //  这里可将请求到的信息发送出去
             
            [subscriber sendNext:value];
             
            [subscriber sendCompleted];
             
            return [RACDisposable disposableWithBlock:^{
                 
                //  cancel request
                 
                // 这里可以将取消请求写在这里,若输入框有新输入信息那么将会发送一个新的请求,原来那个没执行完的请求将会执行这个取消请求的代码
                 
            }];
        }];
         
    }]switchToLatest] subscribeNext:^(id x) {
         
        //这里获取信息
         
    }];
}
 
#pragma mark - lc_map
 
- (void)lc_map {
    //这里可以使用绑定写法来更快捷的达到目的,这里主要是为了体验map所以就不展示了,详情请看RACSignal的绑定
    //这里的映射(map)前面有讲过主要是为了对block的返回值进行处理
//    @weakify(self);
    [[[self.textField rac_textSignal] map:^id(id value) {
         
        return [NSString stringWithFormat:@"名字是:%@",value];
         
    }] subscribeNext:^(id x) {
         
//        @strongify(self);
        NSLog(@"%@",x);
         
    }];
     
     
    //同时使用FlatternMap我们需要导入RACReturnSignal.h
//    @weakify(self);
    [[[self.textField rac_textSignal] flattenMap:^id(id value) {
         
        return [RACReturnSignal return:[NSString stringWithFormat:@"年龄是:%@",value]];
         
    }] subscribeNext:^(id x) {
//        @strongify(self);
        NSLog(@"%@",x);
         
    }];
}
 
#pragma mark - RACCommand
 
- (void)lc_RACCommand {
    /** RACCommand:RAC中用于处理事件的类,可以把事件如何处理,事件中的数据如何传递,包装到这个类中,他可以很方便的监控事件的执行过程。
      
     使用场景:监听按钮点击,网络请求
     **/
     
    // 一、RACCommand使用步骤:
    // 1.创建命令 initWithSignalBlock:(RACSignal * (^)(id input))signalBlock
    // 2.在signalBlock中,创建RACSignal,并且作为signalBlock的返回值
    // 3.执行命令 - (RACSignal *)execute:(id)input
     
    // 二、RACCommand使用注意:
    // 1.signalBlock必须要返回一个信号,不能传nil.
    // 2.如果不想要传递信号,直接创建空的信号[RACSignal empty];
    // 3.RACCommand中信号如果数据传递完,必须调用[subscriber sendCompleted],这时命令才会执行完毕,否则永远处于执行中。
    // 4.RACCommand需要被强引用,否则接收不到RACCommand中的信号,因此RACCommand中的信号是延迟发送的。
     
    // 三、RACCommand设计思想:内部signalBlock为什么要返回一个信号,这个信号有什么用。
    // 1.在RAC开发中,通常会把网络请求封装到RACCommand,直接执行某个RACCommand就能发送请求。
    // 2.当RACCommand内部请求到数据的时候,需要把请求的数据传递给外界,这时候就需要通过signalBlock返回的信号传递了。
     
    // 四、如何拿到RACCommand中返回信号发出的数据。
    // 1.RACCommand有个执行信号源executionSignals,这个是signal of signals(信号的信号),意思是信号发出的数据是信号,不是普通的类型。
    // 2.订阅executionSignals就能拿到RACCommand中返回的信号,然后订阅signalBlock返回的信号,就能获取发出的值。
     
    // 五、监听当前命令是否正在执行executing
     
    // 六、使用场景,监听按钮点击,网络请求
     
     
    UIButton *btn = [UIButton buttonWithType:UIButtonTypeCustom];
    btn.frame = CGRectMake(100, 100, 100, 40);
    btn.backgroundColor = [UIColor redColor];
    [self.view addSubview:btn];
     
    RACSignal* signal = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
        [subscriber sendNext:@"signal1"];
        [subscriber sendNext:@"signal2"];
        [subscriber sendError:[NSError new]];
        return nil;
    }];
     
    // 1.创建命令
    RACCommand *command = [[RACCommand alloc] initWithSignalBlock:^RACSignal *(id input) {
         
         
        NSLog(@"执行命令");
         
        // 创建空信号,必须返回信号
        //        return [RACSignal empty];
         
        // 2.创建信号,用来传递数据
        return signal;
         
    }];
     
    // 强引用命令,不要被销毁,否则接收不到数据
    btn.rac_command = command;
     
     
     
    //    // 3.订阅RACCommand中的信号
    //    [command.executionSignals subscribeNext:^(id x) {
    //        NSLog(@"RACDynamicSignal %@",x);
    //
    //        [x subscribeNext:^(id x) {
    //
    //            NSLog(@"executionSignals %@",x);
    //        }];
    //
    //    }];
    //
    //    // RAC高级用法
    //    // switchToLatest:用于signal of signals,获取signal of signals发出的最新信号,也就是可以直接拿到RACCommand中的信号
    //    [command.executionSignals.switchToLatest subscribeNext:^(id x) {
    //
    //        NSLog(@"switchToLatest %@",x);
    //    }];
    //
    //    // 4.监听命令是否执行完毕,默认会来一次,可以直接跳过,skip表示跳过第一次信号。
    //    [[command.executing skip:1] subscribeNext:^(id x) {
    //
    //        if ([x boolValue] == YES) {
    //            // 正在执行
    //            NSLog(@"正在执行");
    //
    //        }else{
    //            // 执行完成
    //            NSLog(@"执行完成");
    //        }
    //
    //    }];
    // 5.执行命令
    [command execute:@"signal1"];
     
     
     
    //    btn.rac_command
}
 
 
//6.10 RACScheduler:RAC中的队列,用GCD封装的。
//
//6.11 RACUnit :表⽰stream不包含有意义的值,也就是看到这个,可以直接理解为nil.
//
//6.12 RACEvent: 把数据包装成信号事件(signal event)。它主要通过RACSignal的-materialize来使用,然并卵。
#pragma mark - Selector_kvo_event_notification_textchange
 
- (void)lc_Selector_kvo_event_notification_textchange {
    // 1.代替代理
    // 需求:自定义redView,监听红色view中按钮点击
    // 之前都是需要通过代理监听,给红色View添加一个代理属性,点击按钮的时候,通知代理做事情
    // rac_signalForSelector:把调用某个对象的方法的信息转换成信号,就要调用这个方法,就会发送信号。
    // 这里表示只要redV调用btnClick:,就会发出信号,订阅就好了。
     
    UIButton *redV = [UIButton buttonWithType:UIButtonTypeCustom];
     
    [[redV rac_signalForSelector:@selector(btnClick:)] subscribeNext:^(id x) {
        NSLog(@"点击红色按钮");
    }];
     
    // 2.KVO
    // 把监听redV的center属性改变转换成信号,只要值改变就会发送信号
    // observer:可以传入nil
    [[redV rac_valuesAndChangesForKeyPath:@"center" options:NSKeyValueObservingOptionNew observer:nil] subscribeNext:^(id x) {
         
        NSLog(@"%@",x);
         
    }];
     
     
    UIButton *btn = [UIButton buttonWithType:UIButtonTypeCustom];
    // 3.监听事件
    // 把按钮点击事件转换为信号,点击按钮,就会发送信号
    [[btn rac_signalForControlEvents:UIControlEventTouchUpInside] subscribeNext:^(id x) {
         
        NSLog(@"按钮被点击了");
    }];
     
    // 4.代替通知
    // 把监听到的通知转换信号
    [[[NSNotificationCenter defaultCenter] rac_addObserverForName:UIKeyboardWillShowNotification object:nil] subscribeNext:^(id x) {
        NSLog(@"键盘弹出");
    }];
     
    UITextField *field = [[UITextField alloc]init];
    // 5.监听文本框的文字改变
    [field.rac_textSignal subscribeNext:^(id x) {
         
        NSLog(@"文字改变了%@",x);
    }];
     
    // 6.处理多个请求,都返回结果的时候,统一做处理.
    RACSignal *request1 = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
         
        // 发送请求1
        [subscriber sendNext:@"发送请求1"];
        return nil;
    }];
     
    RACSignal *request2 = [RACSignal createSignal:^RACDisposable *(id<RACSubscriber> subscriber) {
        // 发送请求2
        [subscriber sendNext:@"发送请求2"];
        return nil;
    }];
     
    // 使用注意:几个信号,参数一的方法就几个参数,每个参数对应信号发出的数据。
    [self rac_liftSelector:@selector(updateUIWithR1:r2:) withSignalsFromArray:@[request1,request2]];
     
     
}
// 更新UI
- (void)updateUIWithR1:(id)data r2:(id)data1 {
    NSLog(@"更新UI%@  %@",data,data1);
}
 
#pragma mark - ReactiveCocoa常见宏。
/** RAC(TARGET, [KEYPATH, [NIL_VALUE]]):用于给某个对象的某个属性绑定。
 **/
 
//RACObserve(self, name):监听某个对象的某个属性,返回的是信号。
- (void)lc_define {
    [RACObserve(self.view, center) subscribeNext:^(id x) {
         
        NSLog(@"%@",x);
    }];
}
 
#pragma mark - RACTuple。
- (void)lc_RACTuple {
    // 把参数中的数据包装成元组
    RACTuple *tuple2 = RACTuplePack(@10,@20);
     
    RACTuple *tuple = RACTuplePack(@"xmg",@20);
     
    // 解包元组,会把元组的值,按顺序给参数里面的变量赋值
    // name = @"xmg" age = @20
    RACTupleUnpack(NSString *name,NSNumber *age) = tuple;
}
 
 
#pragma mark - skip
- (void)lc_skip {
    RACSubject *subject = [RACSubject subject];
    [[subject skip:2] subscribeNext:^(id x) {
        NSLog(@"%@", x);
    }];
    [subject sendNext:@1];
    [subject sendNext:@2];
    [subject sendNext:@3];
}
 
#pragma mark - distinctUntilChanged
//distinctUntilChanged:-- 如果当前的值跟上一次的值一样,就不会被订阅到
- (void)lc_distinctUntilChanged {
    RACSubject *subject = [RACSubject subject];
    [[subject distinctUntilChanged] subscribeNext:^(id x) {
        NSLog(@"%@", x);
    }];
    // 发送信号
    [subject sendNext:@1];
    [subject sendNext:@2];
    [subject sendNext:@2]; // 不会被订阅
}
 
#pragma mark - take
// take:可以屏蔽一些值,去前面几个值---这里take为2 则只拿到前两个值
- (void)lc_take {
    RACSubject *subject = [RACSubject subject];
    [[subject take:2] subscribeNext:^(id x) {
        NSLog(@"%@", x);
    }];
    // 发送信号
    [subject sendNext:@1];
    [subject sendNext:@2];
    [subject sendNext:@3];
}
 
 
#pragma mark - takeLast
//takeLast:和take的用法一样,不过他取的是最后的几个值,如下,则取的是最后两个值
//注意点:takeLast 一定要调用sendCompleted,告诉他发送完成了,这样才能取到最后的几个值
- (void)lc_takeLast {
    RACSubject *subject = [RACSubject subject];
    [[subject takeLast:2] subscribeNext:^(id x) {
        NSLog(@"%@", x);
    }];
    // 发送信号
    [subject sendNext:@1];
    [subject sendNext:@2];
    [subject sendNext:@3];
    [subject sendCompleted];
}
 
 
#pragma mark - takeUntil
// takeUntil:---给takeUntil传的是哪个信号,那么当这个信号发送信号或sendCompleted,就不能再接受源信号的内容了。
- (void)lc_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];
}
 
 
#pragma mark - ignore
// ignore: 忽略掉一些值
- (void)lc_ignore {
    //ignore:忽略一些值
    //ignoreValues:表示忽略所有的值
    // 1.创建信号
    RACSubject *subject = [RACSubject subject];
     
#if 0
    // 2.忽略一些值
    RACSignal *ignoreSignal = [subject ignore:@2]; // ignoreValues:表示忽略所有的值
    // 3.订阅信号
    [ignoreSignal subscribeNext:^(id x) {
        NSLog(@"%@", x);
    }];
    // 4.发送数据
    [subject sendNext:@2];
     
#else
    [subject filter:^BOOL(NSNumber * _Nullable value) {
        return value.integerValue != 2;
    }];
#endif
     
}
 
 
 
#pragma mark - fliter
// 一般和文本框一起用,添加过滤条件
- (void)lc_fliter {
     
    // 只有当文本框的内容长度大于5,才获取文本框里的内容
    [[self.textField.rac_textSignal filter:^BOOL(id value) {
        // value 源信号的内容
        return [value length] > 5;
        // 返回值 就是过滤条件。只有满足这个条件才能获取到内容
    }] subscribeNext:^(id x) {
        NSLog(@"%@", x);
    }];
}
 
/**
 6.10 RACScheduler:RAC中的队列,用GCD封装的。
  
 6.11 RACUnit :表⽰stream不包含有意义的值,也就是看到这个,可以直接理解为nil.
  
 6.12 RACEvent: 把数据包装成信号事件(signal event)。它主要通过RACSignal的-materialize来使用,然并卵。
  
  
 **/
 
 
@end

  

 

posted on   iRemark  阅读(275)  评论(0编辑  收藏  举报

编辑推荐:
· .NET Core GC计划阶段(plan_phase)底层原理浅谈
· .NET开发智能桌面机器人:用.NET IoT库编写驱动控制两个屏幕
· 用纯.NET开发并制作一个智能桌面机器人:从.NET IoT入门开始
· 一个超经典 WinForm,WPF 卡死问题的终极反思
· ASP.NET Core - 日志记录系统(二)
阅读排行:
· 支付宝事故这事儿,凭什么又是程序员背锅?有没有可能是这样的...
· 在线客服系统 QPS 突破 240/秒,连接数突破 4000,日请求数接近1000万次,.NET 多
· C# 开发工具Visual Studio 介绍
· 在 Windows 10 上实现免密码 SSH 登录
· C#中如何使用异步编程

导航

< 2025年1月 >
29 30 31 1 2 3 4
5 6 7 8 9 10 11
12 13 14 15 16 17 18
19 20 21 22 23 24 25
26 27 28 29 30 31 1
2 3 4 5 6 7 8
点击右上角即可分享
微信分享提示