框架组成介绍

By admin in 4858.com on 2019年4月13日

RAC类关系图:

4858.com 1


 

RAC类关系图:

4858.com 2


 

小说来源此链接

原文:Framework Overview

RAC 信号源:

4858.com 3


RAC 信号源:

4858.com 4


多年来再重新学习swift,从OC的RAC转到Swift的RAC方法调用大变样,各个的不适于。

自家翻译的RAC四的文书档案ReactiveCocoa 四 官方文书档案翻译ReactiveCocoa 4文书档案翻译:基本操作符ReactiveCocoa 四 文书档案翻译:基本操作符ReactiveCocoa
四 文书档案翻译:框架组成介绍ReactiveCocoa 四文档翻译:包容Objective-CReactiveCocoa 四文书档案翻译–设计指南:事件的正式ReactiveCocoa 4文书档案翻译:设计指南:时域信号的正经[翻译]ReactiveCocoa ④ 最棒实践

 必要导入的头文件:

1 import ReactiveCocoa
2 import Result
3 import ReactiveSwift

 

 须要导入的头文件:

1 import ReactiveCocoa
2 import Result
3 import ReactiveSwift

 

简言之明白

更换的门类有:RACSignal 和 SignalProducer、 SignalRACCommand 和
ActionRACScheduler 和 SchedulerTypeRACDisposable 和 Disposable

需使用的头文件

import ReactiveCocoa

import Result

import ReactiveSwift

框架组成:一.事件二.监听器三.清洁者(Disposable)肆.实信号伍.管道:6.时限信号生产者:(Signal
Producers)柒.缓冲:⑧.动作:9.属性:(Properties)拾.调度器:(Schedulers)

从OC的RAC转到Swift的RAC方法调用大变样.

本文将以全部框架的惊人介绍RAC框架中的首要构成成分,尝试表达它们是怎么构成在共同坐班和各自的天职。那会推向你读书新模块和搜索有关详细表达的文书档案。关于RAC的例子和应有怎么利用能够查看这八个文书档案:ReactiveCocoa
四 官方文书档案翻译:ReadMe 大概 Design Guidelines。

冷信号

 1  //1.冷信号
 2         let producer = SignalProducer<String, NoError>.init { (observer, _) in
 3             print("新的订阅,启动操作")
 4             observer.send(value: "Hello")
 5             observer.send(value: "World")
 6             observer.sendCompleted()
 7         }
 8         
 9         //创建观察者 (多个观察者观察会有副作用)
10         let sub1 = Signal<String, NoError>.Observer(value: { (value) in
11             print("观察者1接受信号\(value)")
12         })
13         
14         let sub2 = Signal<String, NoError>.Observer(value: { (value) in
15             print("观察者2接受信号\(value)")
16         })
17         //观察者订阅信号
18         print("观察者1订阅信号")
19         producer.start(sub1)
20         print("观察者2订阅信号")
21         producer.start(sub2)

结果:

4858.com 5


 

冷信号

 1  //1.冷信号
 2         let producer = SignalProducer<String, NoError>.init { (observer, _) in
 3             print("新的订阅,启动操作")
 4             observer.send(value: "Hello")
 5             observer.send(value: "World")
 6             observer.sendCompleted()
 7         }
 8         
 9         //创建观察者 (多个观察者观察会有副作用)
10         let sub1 = Signal<String, NoError>.Observer(value: { (value) in
11             print("观察者1接受信号\(value)")
12         })
13         
14         let sub2 = Signal<String, NoError>.Observer(value: { (value) in
15             print("观察者2接受信号\(value)")
16         })
17         //观察者订阅信号
18         print("观察者1订阅信号")
19         producer.start(sub1)
20         print("观察者2订阅信号")
21         producer.start(sub2)

结果:

4858.com 6


 

1.冷信号

func bindSignal1(){ //1.冷信号 let producer = SignalProducer<String, NoError>.init { (observer, _) in print("新的订阅,启动操作") observer.send(value: "Hello") observer.send(value: "World") observer.sendCompleted() } //创建观察者 (多个观察者观察会有副作用) let sub1 = Observer<String, NoError>(value: { print("观察者1接受信号\ let sub2 = Observer<String, NoError>(value: { print("观察者2接受信号\ //观察者订阅信号 print("观察者1订阅信号") producer.start print("观察者2订阅信号") producer.start }

一个事件, 用<code> 伊夫nt </code>类型表示,
表示某个事情已经产生。 在RAC中事件是流传(center-piece of
communication)的大旨。
一个风浪可能是button的2遍点击,从API重返的局地音讯,三个不当的发出,或许3个长日子操作达成了。无论怎么样,1些东西发滋事件,然后通过signal发送给每一种订阅那一个signal的观望者。

热信号

 1 //        热信号 (通过管道创建)
 2         let (signalA, observerA) = Signal<String, NoError>.pipe()
 3         let (signalB, observerB) = Signal<Int, NoError>.pipe()
 4         
 5         Signal.combineLatest(signalA,signalB).observeValues { (value) in
 6             print("两个热信号收到的值\(value.0) + \(value.1)")
 7         }
 8         //订阅信号要在send之前
 9         signalA.observeValues { (value) in
10             print("signalA : \(value)")
11         }
12         
13         observerA.send(value: "sssss")
14         //        observerA.sendCompleted()
15         observerB.send(value: 2)
16         //        observerB.sendCompleted()
17         
18         observerB.send(value: 100)
19         //不sendCompleted和sendError 热信号一直激活
20         //        observerB.sendCompleted()

结果: 4858.com 7 


 

热信号

 1 //        热信号 (通过管道创建)
 2         let (signalA, observerA) = Signal<String, NoError>.pipe()
 3         let (signalB, observerB) = Signal<Int, NoError>.pipe()
 4         
 5         Signal.combineLatest(signalA,signalB).observeValues { (value) in
 6             print("两个热信号收到的值\(value.0) + \(value.1)")
 7         }
 8         //订阅信号要在send之前
 9         signalA.observeValues { (value) in
10             print("signalA : \(value)")
11         }
12         
13         observerA.send(value: "sssss")
14         //        observerA.sendCompleted()
15         observerB.send(value: 2)
16         //        observerB.sendCompleted()
17         
18         observerB.send(value: 100)
19         //不sendCompleted和sendError 热信号一直激活
20         //        observerB.sendCompleted()

结果: 4858.com 8 


 

2.热信号

func bindSignal2(){ //2.热信号  let (signalA, observerA) = Signal<String, NoError>.pipe() let (signalB, observerB) = Signal<Int, NoError>.pipe() Signal.combineLatest(signalA,signalB).observeValues {  in print("两个热信号收到的值\ + \") } //订阅信号要在send之前 signalA.observeValues {  in print("signalA : \ } observerA.send(value: "sssss") // observerA.sendCompleted() observerB.send // observerB.sendCompleted() observerB.send(value: 100) //不sendCompleted和sendError 热信号一直激活 // observerB.sendCompleted()}

<code> Event
</code>是2个枚举类型,也许有八种值(Next中有值,别的二种表示停止):

文本框监听

1 func racsTest() {
2         textField.reactive.continuousTextValues.observeValues { (text) in
3             
4             print("值为:\(text ?? "")")
5             
6         }
7     }

 

结果:

4858.com 9


 

文本框监听

1 func racsTest() {
2         textField.reactive.continuousTextValues.observeValues { (text) in
3             
4             print("值为:\(text ?? "")")
5             
6         }
7     }

 

结果:

4858.com 10


 

三.监听文本框

func bindSignal3(){ //2文本输入框的监听 nameTF.reactive.continuousTextValues.observeValues {  in print(text ?? "") } //监听黏贴进来的文本 let result = nameTF.reactive.values(forKeyPath: "text") result.start {  in print } //按钮监听 loginBtn.reactive.controlEvents(.touchUpInside).observeValues {  in print }}
  • <code> Next </code>代表有3个新的值从源发生。
  • <code> Failed
    </code>表明在复信号源达成前发生了3个错误。事件会被作为三个类型为<code>
    ErrorType
    </code>的参数,1种在事件中声称过的意味已知错误的种类。假设那一个错误未有被声称许可过,能够用<code>
    NoError </code>表示。
  • <code> Completed
    </code>表明事件早已打响结束。不会再有值发送出来。
  • <code> Interrupted
    </code>表明事件被打消了,意味着操作既未能如愿也从没失败。

Map映射 用于将一个轩然大波流的值操作后的结果产生三个新的事件流。

方法一:

textField.reactive.continuousTextValues.map { (text) -> Int in

            return (text?.count)!//!.characters.count

            }.observeValues { (count) in

                print("数值为:\(count)")

        }

输入: Hello123

结果为:

4858.com 11

 

方法二:

 1 let (signal, observer) = Signal<String, NoError>.pipe()
 2         signal.map { (string) -> Int in
 3             return string.lengthOfBytes(using: .utf8)
 4             }.observeValues { (length) in
 5                 print("长度length: \(length)")
 6         }
 7         
 8         observer.send(value: "123456")
 9         
10         observer.send(value: "some")

结果为:

4858.com 12


 

Map映射 用于将三个轩然大波流的值操作后的结果发生二个新的风云流。

方法一:

textField.reactive.continuousTextValues.map { (text) -> Int in

            return (text?.count)!//!.characters.count

            }.observeValues { (count) in

                print("数值为:\(count)")

        }

输入: Hello123

结果为:

4858.com 13

 

方法二:

 1 let (signal, observer) = Signal<String, NoError>.pipe()
 2         signal.map { (string) -> Int in
 3             return string.lengthOfBytes(using: .utf8)
 4             }.observeValues { (length) in
 5                 print("长度length: \(length)")
 6         }
 7         
 8         observer.send(value: "123456")
 9         
10         observer.send(value: "some")

结果为:

4858.com 14


 

四.复信号合并

合成后的新事件流唯有在收到各样合成流的起码2个值后才会发送出去。接着就会把各样流的风靡的值壹起输出。

func bindSignal4(){ //4.信号合并 两个要被订阅combineLatest 才能被订阅,被订阅后,合并中其中一个sendNext都会激活订阅 let (signalA, observerA) = Signal<String, NoError>.pipe() let (signalB, observerB) = Signal<Array<Any> , NoError>.pipe() Signal.combineLatest(signalA, signalB).observeValues {  in print("合并的信号:\ } observerA.send(value: "xxx") observerA.sendCompleted() observerB.send(value: ["sdsd","ddddd"]) observerB.sendCompleted() }

3个复信号, 用 <code> Signal
</code>类型表示,是类别随着时间爆发的能够被调查的轩然大波。

Filter函数能够依照事先预设的尺码过滤掉不满意的值

方法一:

1 textField.reactive.continuousTextValues.filter { (text) -> Bool in
2             
3             return text!.characters.count > 3
4             
5             }.observeValues { (text) in
6                 
7                 print(text ?? "")
8                 
9         }

输入: 1234

结果:

1234 

 

方法二:

 1 let (signal, observer) = Signal<Int, NoError>.pipe()
 2         signal.filter { (value) -> Bool in
 3             return value % 2 == 0
 4             }.observeValues { (value) in
 5                 print("\(value)能被2整除")
 6         }
 7         observer.send(value: 3)
 8         observer.send(value: 4)
 9         observer.send(value: 6)
10         observer.send(value: 7)

 

结果:

4能被2整除

6能被2整除


 

框架组成介绍。Filter函数能够遵守事先预设的口径过滤掉不知足的值

方法一:

1 textField.reactive.continuousTextValues.filter { (text) -> Bool in
2             
3             return text!.characters.count > 3
4             
5             }.observeValues { (text) in
6                 
7                 print(text ?? "")
8                 
9         }

输入: 1234

结果:

1234 

 

4858.com,方法二:

 1 let (signal, observer) = Signal<Int, NoError>.pipe()
 2         signal.filter { (value) -> Bool in
 3             return value % 2 == 0
 4             }.observeValues { (value) in
 5                 print("\(value)能被2整除")
 6         }
 7         observer.send(value: 3)
 8         observer.send(value: 4)
 9         observer.send(value: 6)
10         observer.send(value: 7)

 

结果:

4能被2整除

6能被2整除


 

5.非信号联合

zip中的功率信号都要被订阅才能激活,意味着1旦是二个流的第N个成分,一定要等到此外1个流第N值也收到才会联合组成爆发。

func bindSignal5(){ //5.信号联合 let (signalA, observerA) = Signal<String, NoError>.pipe() let (signalB, observerB) = Signal<String, NoError>.pipe() //两个到需要订阅 才激活zip Signal.zip(signalA, signalB).observeValues {  in print("zip: \ } observerA.send(value: "1")// observerA.sendCompleted() observerB.send(value: "2")// observerB.sendCompleted() observerB.send(value: "cc") observerA.send(value: "dd")}

非功率信号经常用来表示事件流正在发生,比如公告,用户的输入等。每当动作被实施可能数额已经接受,事件们就会透过signal发出,signal会把它们推送给每种观望者。全体的观看者都会同时接受到事件。

时限信号合并

合成后的新事件流只有在收受各类合成流的起码一个值后才会发送出去。接着就会把各类流的摩登的值一起输出。

 1 //        信号合并 两个要被订阅combineLatest 才能被订阅,被订阅后,合并中其中一个sendNext都会激活订阅
 2         let (signalA, observerA) = Signal<String, NoError>.pipe()
 3         let (signalB, observerB) = Signal<Array<Any> , NoError>.pipe()
 4         Signal.combineLatest(signalA, signalB).observeValues { (value) in
 5             print("合并的信号:\(value)")
 6         }
 7         
 8         observerA.send(value: "xxx")
 9         observerA.sendCompleted()
10         observerB.send(value: ["sdsd","ddddd"])
11         observerB.sendCompleted()

结果:

4858.com 15


 

频限信号合并

合成后的新事件流唯有在收取每一种合成流的足足二个值后才会发送出去。接着就会把各样流的新颖的值壹起输出。

 1 //        信号合并 两个要被订阅combineLatest 才能被订阅,被订阅后,合并中其中一个sendNext都会激活订阅
 2         let (signalA, observerA) = Signal<String, NoError>.pipe()
 3         let (signalB, observerB) = Signal<Array<Any> , NoError>.pipe()
 4         Signal.combineLatest(signalA, signalB).observeValues { (value) in
 5             print("合并的信号:\(value)")
 6         }
 7         
 8         observerA.send(value: "xxx")
 9         observerA.sendCompleted()
10         observerB.send(value: ["sdsd","ddddd"])
11         observerB.sendCompleted()

结果:

4858.com 16


 

6.调度器

func bindSiganl6() { //6.调度器 QueueScheduler.main.schedule(after: Date.init(timeIntervalSinceNow: 3)) { print("主线程3秒过去了") } QueueScheduler.init().schedule(after: Date.init(timeIntervalSinceNow: 2)) { print("子线程2秒过去了") }}

用户借使想要接收它们的事件必须observe这些signal。观望三个实信号不会触发其余副成效。换句话说,事件是源驱动,基于推送,观看者在全部生命周期里不见面临到其余影响。当旁观3个非时域信号时,用户只好遵照顺序处理时限信号里的事件。不可能随便走访信号里的风云。

时限信号联合

zip中的非确定性信号都要被订阅才能激活,意味着一旦是2个流的第N个要素,一定要等到其它一个流第N值也收到才会1起组成爆发。 

 1 //        信号联合
 2         let (signalA, observerA) = Signal<String, NoError>.pipe()
 3         let (signalB, observerB) = Signal<String, NoError>.pipe()
 4         
 5         //两个到需要订阅 才激活zip
 6         Signal.zip(signalA, signalB).observeValues { (value) in
 7             print("zip: \(value)")
 8         }
 9         
10         observerA.send(value: "1")
11 //                observerA.sendCompleted()
12         observerB.send(value: "2")
13 //                observerB.sendCompleted()
14         observerB.send(value: "cc")
15         observerA.send(value: "dd")

结果:

4858.com 17


 

非功率信号联合

zip中的功率信号都要被订阅才能激活,意味着一旦是三个流的第N个因素,一定要等到此外二个流第N值也收到才会联手组成爆发。 

 1 //        信号联合
 2         let (signalA, observerA) = Signal<String, NoError>.pipe()
 3         let (signalB, observerB) = Signal<String, NoError>.pipe()
 4         
 5         //两个到需要订阅 才激活zip
 6         Signal.zip(signalA, signalB).observeValues { (value) in
 7             print("zip: \(value)")
 8         }
 9         
10         observerA.send(value: "1")
11 //                observerA.sendCompleted()
12         observerB.send(value: "2")
13 //                observerB.sendCompleted()
14         observerB.send(value: "cc")
15         observerA.send(value: "dd")

结果:

4858.com 18


 

7.通知

func bindSignal7(){ //7.通知 NotificationCenter.default.reactive.notifications(forName: Notification.Name(rawValue: "UIKeyboardWillShowNotification"), object: nil).observeValues { (notification) in print } NotificationCenter.default.reactive.notifications(forName: Notification.Name(rawValue:"UIKeyboardWillHideNotification"), object: nil).observeValues { (notification) in print }}

时域信号能够被操作符操作。常用的操作一个实信号的有filter,map和reduce,zip能够3回拍卖八个功率信号源。操作符只辛亏Next事件中才能使用。(具体操作符能够参照笔者翻的这篇:ReactiveCocoa
肆 文书档案翻译:基本操作符)

调度器

1    QueueScheduler.main.schedule(after: Date.init(timeIntervalSinceNow: 3)) {
2             print("主线程3秒过去了")
3         }
4         QueueScheduler.init().schedule(after: Date.init(timeIntervalSinceNow: 2)) {
5             print("子线程2秒过去了")
6         }

结果:4858.com 19


 

调度器

1    QueueScheduler.main.schedule(after: Date.init(timeIntervalSinceNow: 3)) {
2             print("主线程3秒过去了")
3         }
4         QueueScheduler.init().schedule(after: Date.init(timeIntervalSinceNow: 2)) {
5             print("子线程2秒过去了")
6         }

结果:4858.com 20


 

8.KVO

func bindSignal8(){ //8KVO let result = self.nameTF.reactive.values(forKeyPath: "text") result.start {  in print; }}

数字信号的任何生命周期有一组Next事件组成,最后是二个终了事件,可能是Failed,
Completed,
或然Interrupted中的任一个。终结事件尚无被含有在事变的值里,他们须要被单独处理。

通知

1 //        通知
2         NotificationCenter.default.reactive.notifications(forName: Notification.Name(rawValue: "UIKeyboardWillShowNotification"), object: nil).observeValues { (notification) in
3             print("键盘弹起")
4         }
5         
6         NotificationCenter.default.reactive.notifications(forName: Notification.Name(rawValue:"UIKeyboardWillHideNotification"), object: nil).observeValues { (notification) in
7             print("键盘收起")
8         }

结果:

4858.com 21


 

通知

1 //        通知
2         NotificationCenter.default.reactive.notifications(forName: Notification.Name(rawValue: "UIKeyboardWillShowNotification"), object: nil).observeValues { (notification) in
3             print("键盘弹起")
4         }
5         
6         NotificationCenter.default.reactive.notifications(forName: Notification.Name(rawValue:"UIKeyboardWillHideNotification"), object: nil).observeValues { (notification) in
7             print("键盘收起")
8         }

结果:

4858.com 22


 

9.迭代器

func bindSignal9() { //9.迭代器 let array:[String] = ["name1", "name2"] var arrayIterator = array.makeIterator() while let temp = arrayIterator.next() { print } //swift系统自带 array.forEach {  in print } }

八个管道,通过
<code>Signal.pipe()</code>创造。一个足以被手动控制的连续信号。那几个艺术重返三个非数字信号和一个observer。能够操纵非功率信号发送事件给观看者。这些在将非RAC的代码转变到时域信号世界里专门有用。

KVO 

1 let result = self.textField.reactive.producer(forKeyPath: "text")
2         result.start { (text) in
3             print("----------->\(text)");
4         }

 输入:Hello

留神:输叁个字符,Return 一下,不然监听不到

结果:

4858.com 23

 


 

KVO 

1 let result = self.textField.reactive.producer(forKeyPath: "text")
2         result.start { (text) in
3             print("----------->\(text)");
4         }

 输入:Hello

专注:输一个字符,Return 一下,不然监听不到

结果:

4858.com 24

 


 

10.on

能够因此 on来考查signal,生成3个新的非实信号,尽管没有订阅者也会被触发。和
observe相似,也得以只观察您爱戴的有些事件。必要提到的是
producer要started后才会触发。

 let signal = SignalProducer<String , NoError>.init { (obsever, _) in obsever.send(value: "ddd") obsever.sendCompleted() } //可以通过 on来观察signal,生成一个新的信号,即使没有订阅者(sp.start也会被触发。 let sp = signal.on(starting: { print }, started: { print }, event: {  in print("Event: \ }, failed: {  in print("error: \ }, completed: { print }, interrupted: { print }, terminated: { print }, disposed: { print }) {  in print("value: \ } sp.start()

打字与印刷结果:

开始Event: VALUE dddvalue: dddEvent: COMPLETED信号完成信号结束信号清理结束

比如,能够不用在block的回调里处理工作逻辑,将blocks简化成发送事件给观看者。同时功率信号可以被重临,隐藏回调里的现实贯彻。

迭代器

 1 //        迭代器
 2         let array:[String] = ["name1", "name2"]
 3         var arrayIterator = array.makeIterator()
 4         while let temp = arrayIterator.next() {
 5             print(temp)
 6         }
 7         
 8         //swift系统自带
 9         array.forEach { (value) in
10             print("系统自带:\(value)")
11         }

结果:

4858.com 25


 

迭代器

 1 //        迭代器
 2         let array:[String] = ["name1", "name2"]
 3         var arrayIterator = array.makeIterator()
 4         while let temp = arrayIterator.next() {
 5             print(temp)
 6         }
 7         
 8         //swift系统自带
 9         array.forEach { (value) in
10             print("系统自带:\(value)")
11         }

结果:

4858.com 26


 

11.Map

Map映射 用于将一个事变流的值操作后的结果产生1个新的轩然大波流。

let (signal, observer) = Signal<String, NoError>.pipe()signal.map {  -> Int in return string.lengthOfBytes(using: .utf8)}.observeValues {  in print("length: \} observer.send(value: "lemon") observer.send(value: "something")

1个随机信号生产者,以 <code> SignalProducer
</code>类型表示,成立能量信号并且爆发副作用。

on

能够经过 on来观望signal,生成一个新的实信号,即便未有订阅者也会被触发。
和 observe相似,也得以只旁观您爱护的某部事件。
亟待提到的是 producer要started后才会接触。

 1 let signal = SignalProducer<String , NoError>.init { (obsever, _) in
 2             obsever.send(value: "SignalProducer")
 3             obsever.sendCompleted()
 4         }
 5         
 6         //可以通过 on来观察signal,生成一个新的信号,即使没有订阅者(sp.start())也会被触发。
 7         let sp = signal.on(starting: {
 8             print("开始")
 9         }, started: {
10             print("结束")
11         }, event: { (event) in
12             print("Event: \(event)")
13         }, failed: { (error) in
14             print("error: \(error)")
15         }, completed: {
16             print("信号完成")
17         }, interrupted: {
18             print("信号被中断")
19         }, terminated: {
20             print("信号结束")
21         }, disposed: {
22             print("信号清理")
23         }) { (value) in
24             print("value: \(value)")
25         }
26         
27         sp.start()

结果:

4858.com 27


 

on

能够透过 on来察看signal,生成三个新的时域信号,固然没有订阅者也会被触发。
和 observe相似,也得以只观望您保养的某部事件。
亟待提到的是 producer要started后才会接触。

 1 let signal = SignalProducer<String , NoError>.init { (obsever, _) in
 2             obsever.send(value: "SignalProducer")
 3             obsever.sendCompleted()
 4         }
 5         
 6         //可以通过 on来观察signal,生成一个新的信号,即使没有订阅者(sp.start())也会被触发。
 7         let sp = signal.on(starting: {
 8             print("开始")
 9         }, started: {
10             print("结束")
11         }, event: { (event) in
12             print("Event: \(event)")
13         }, failed: { (error) in
14             print("error: \(error)")
15         }, completed: {
16             print("信号完成")
17         }, interrupted: {
18             print("信号被中断")
19         }, terminated: {
20             print("信号结束")
21         }, disposed: {
22             print("信号清理")
23         }) { (value) in
24             print("value: \(value)")
25         }
26         
27         sp.start()

结果:

4858.com 28


 

12.filter

//filter函数能够依据从前预设的条件过滤掉不满意的值

let (signal, observer) = Signal<Int, NoError>.pipe()signal.filter {  -> Bool in return value % 2 == 0}.observeValues {  in print能被2整除")}observer.sendobserver.sendobserver.sendobserver.send

能够用来代表一组操作依然任务,比如网络请求,每一遍<code>
start()</code>调用后会创造2个新的操作,允许发起者观望结果。通过<code>
startWithSignal()</code>能够访问到发出的复信号,允许被反复观测。

reduce

reduce将事件里的值聚集后组合成一个值

 1 let (signal, observer) = Signal<Int, NoError>.pipe()
 2         //reduce后的是聚合的次数
 3         signal.reduce(3) { (a, b) -> Int in
 4             //a是相乘后的值 b是传入值
 5             print("a:\(a) b:\(b)")
 6             return a * b
 7             }.observeValues { (value) in
 8                 print("输出的值是:\(value)")
 9         }
10         
11         observer.send(value: 2)
12         observer.send(value: 5)
13         observer.send(value: 4)
14         //要注意的是最后算出来的值直到输入的流完成后才会被发送出去。
15         observer.sendCompleted()

结果:

4858.com 29


 

reduce

reduce将事件里的值聚集后组合成3个值

 1 let (signal, observer) = Signal<Int, NoError>.pipe()
 2         //reduce后的是聚合的次数
 3         signal.reduce(3) { (a, b) -> Int in
 4             //a是相乘后的值 b是传入值
 5             print("a:\(a) b:\(b)")
 6             return a * b
 7             }.observeValues { (value) in
 8                 print("输出的值是:\(value)")
 9         }
10         
11         observer.send(value: 2)
12         observer.send(value: 5)
13         observer.send(value: 4)
14         //要注意的是最后算出来的值直到输入的流完成后才会被发送出去。
15         observer.sendCompleted()

结果:

4858.com 30


 

13.reduce

reduce将事件里的值聚集后组合成三个值

let (signal, observer) = Signal<Int, NoError>.pipe()//reduce后的是聚合的次数signal.reduce {  -> Int in //a是相乘后的值 b是传入值 print b:\ return a * b}.observeValues {  in print} observer.sendobserver.sendobserver.send//要注意的是最后算出来的值直到输入的流完成后才会被发送出去。observer.sendCompleted()

因为<code>
start()</code>这种作为的分裂,每趟从同1个功率信号生产者也许会获取区别顺序或然版本的事件,甚至整个流或者完全两样。不像2个平淡无奇的时限信号,直到有2个观看者被添加才会开首起步,每一遍都会为新加上的观看者重新工作3遍。

flatten

flatten
将1个轩然大波流里的事件流变成三个单1的风云流。新的风云流的值依据钦点的策略(FlattenStrategy)由中间的轩然大波流的值组成。
被压平的值根据会成为外层的流的花色。比如:叁个SignalProducers里的Signal,被flatten后的档次是SignalProducers。


 

flatten

flatten
将2个事变流里的风浪流变成一个纯粹的轩然大波流。新的轩然大波流的值根据钦命的方针(FlattenStrategy)由中间的风浪流的值组成。
被压平的值遵照会化为外层的流的档次。比如:三个SignalProducers里的Signal,被flatten后的种类是SignalProducers。


 

14.flatten

flatten
将三个轩然大波流里的事件流变成三个纯粹的事件流。新的风云流的值根据内定的策略(FlattenStrategy)由个中的轩然大波流的值组成。被压平的值根据会成为外层的流的类别。比如:贰个SignalProducers里的Signal,被flatten后的连串是SignalProducers。

翻开一个功率信号生产者会回到1个<code> disposable
</code>,用了中断可能吊销(interrupt/cancel)那几个数字信号生产者的做事。和时限信号1样,时域信号生产者能够被操作符比如map,filter等操作。每一个数字信号的操作符都能够由此“lifted”迁移后在功率信号生产者上利用。而且,还有多少个特有的操作符用了控制工作如何时候初始和怎么运营,比如<code>
times </code>。

合并

回顾的说就是merge遵照时间顺序组成,concat则是比照内部全体流顺序组合。latest是只记录以来二次恢复生机的值的很是流。

 .一 Merge
策略将种种流的值立时组合输出。无论内部照旧外层的流假若收到退步就结束。

 1 let (producerA, lettersObserver) = Signal<String, NoError>.pipe()
 2         let (producerB, numbersObserver) = Signal<String, NoError>.pipe()
 3         let (signal, observer) = Signal<Signal<String, NoError>, NoError>.pipe()
 4         signal.flatten(.merge).observeValues { (value) in
 5             print("value: \(value)")
 6         }
 7         observer.send(value: producerA)
 8         observer.send(value:producerB)
 9         observer.sendCompleted()
10         lettersObserver.send(value:"埃及") // prints "a"
11         numbersObserver.send(value:"1") // prints "1"
12         lettersObserver.send(value:"罗马") // prints "b"
13         numbersObserver.send(value:"2") // prints "2"
14         lettersObserver.send(value:"瑞典") // prints "c"
15         numbersObserver.send(value:"3") // prints "3"

结果: 

4858.com 31


 

.2 Concat
策略是将中间的SignalProducer排序。外层的producer是即刻被started。随后的producer直到前一个出殡和埋葬实现后才会start。一有曲折立刻传到外层。 

 

 1 let (signalA, lettersObserver) = Signal<Any, NoError>.pipe()
 2         let (signalB, numberObserver) = Signal<Any, NoError>.pipe()
 3         
 4         let (siganl, observer) = Signal<Signal<Any, NoError>, NoError>.pipe()
 5         
 6         siganl.flatten(.concat).observeValues { (value) in
 7             print("value: \(value)")
 8         }
 9         observer.send(value: signalA)
10         observer.send(value: signalB)
11         observer.sendCompleted()
12         
13         lettersObserver.send(value: "dddd")//dddd
14         numberObserver.send(value: 33)    //不打印是因为lettersObserver的发送值没有结束,所以 44 能打印出来
15         
16         lettersObserver.send(value: "sss")//sss
17         lettersObserver.send(value: "ffff")//ffff
18         lettersObserver.sendCompleted()
19         //要前一个信号执行完毕后,下一个信号才能被订阅
20         numberObserver.send(value: 44)// 44

结果:

4858.com 32

 

.3 latest只接到最新进来的相当流的值

 1         let (signalA, lettersObserver) = Signal<Any, NoError>.pipe()
 2         let (signalB, numberObserver) = Signal<Any, NoError>.pipe()
 3         
 4         let (siganl, observer) = Signal<Signal<Any, NoError>, NoError>.pipe()
 5         
 6         siganl.flatten(.latest).observeValues { (value) in
 7             print("value: \(value)")
 8         }
 9         observer.send(value: signalA)
10         //        observer.send(value: signalB)
11         
12         lettersObserver.send(value: "dddd")  //dddd
13         numberObserver.send(value: 33)      //不打印
14         lettersObserver.send(value: "sss")  //sss
15         observer.send(value: signalB)
16         //只接受最近进来的信号
17         numberObserver.send(value: 44)  //44
18         lettersObserver.send(value: "ffff") // 不打印

 

结果:

4858.com 33


 

合并

简简单单的说正是merge遵从时间顺序组成,concat则是根据内部整套流顺序组合。latest是只记录以来3次苏醒的值的要命流。

 .一 Merge
策略将各种流的值马上组合输出。无论内部依然外层的流若是收到失利就停下。

 1 let (producerA, lettersObserver) = Signal<String, NoError>.pipe()
 2         let (producerB, numbersObserver) = Signal<String, NoError>.pipe()
 3         let (signal, observer) = Signal<Signal<String, NoError>, NoError>.pipe()
 4         signal.flatten(.merge).observeValues { (value) in
 5             print("value: \(value)")
 6         }
 7         observer.send(value: producerA)
 8         observer.send(value:producerB)
 9         observer.sendCompleted()
10         lettersObserver.send(value:"埃及") // prints "a"
11         numbersObserver.send(value:"1") // prints "1"
12         lettersObserver.send(value:"罗马") // prints "b"
13         numbersObserver.send(value:"2") // prints "2"
14         lettersObserver.send(value:"瑞典") // prints "c"
15         numbersObserver.send(value:"3") // prints "3"

结果: 

4858.com 34


 

.2 Concat
策略是将在那之中的SignalProducer排序。外层的producer是立即被started。随后的producer直到前二个发送实现后才会start。一有失利立即传到外层。 

 

 1 let (signalA, lettersObserver) = Signal<Any, NoError>.pipe()
 2         let (signalB, numberObserver) = Signal<Any, NoError>.pipe()
 3         
 4         let (siganl, observer) = Signal<Signal<Any, NoError>, NoError>.pipe()
 5         
 6         siganl.flatten(.concat).observeValues { (value) in
 7             print("value: \(value)")
 8         }
 9         observer.send(value: signalA)
10         observer.send(value: signalB)
11         observer.sendCompleted()
12         
13         lettersObserver.send(value: "dddd")//dddd
14         numberObserver.send(value: 33)    //不打印是因为lettersObserver的发送值没有结束,所以 44 能打印出来
15         
16         lettersObserver.send(value: "sss")//sss
17         lettersObserver.send(value: "ffff")//ffff
18         lettersObserver.sendCompleted()
19         //要前一个信号执行完毕后,下一个信号才能被订阅
20         numberObserver.send(value: 44)// 44

结果:

4858.com 35

 

.三 latest只收到最新进来的要命流的值

 1         let (signalA, lettersObserver) = Signal<Any, NoError>.pipe()
 2         let (signalB, numberObserver) = Signal<Any, NoError>.pipe()
 3         
 4         let (siganl, observer) = Signal<Signal<Any, NoError>, NoError>.pipe()
 5         
 6         siganl.flatten(.latest).observeValues { (value) in
 7             print("value: \(value)")
 8         }
 9         observer.send(value: signalA)
10         //        observer.send(value: signalB)
11         
12         lettersObserver.send(value: "dddd")  //dddd
13         numberObserver.send(value: 33)      //不打印
14         lettersObserver.send(value: "sss")  //sss
15         observer.send(value: signalB)
16         //只接受最近进来的信号
17         numberObserver.send(value: 44)  //44
18         lettersObserver.send(value: "ffff") // 不打印

 

结果:

4858.com 36


 

15.合并

一言以蔽之就是merge依据时间顺序组成,concat则是依照内部全体流顺序组合。latest是只记录以来三遍恢复生机的值的不胜流。

1 .merge.Merge
策略将各样流的值马上组合输出。无论内部照旧外层的流假使收到战败就止住。

let (producerA, lettersObserver) = Signal<String, NoError>.pipe()let (producerB, numbersObserver) = Signal<String, NoError>.pipe()let (signal, observer) = Signal<Signal<String, NoError>, NoError>.pipe()signal.flatten.observeValues {  in print("value: \}observer.send(value: producerA)observer.send(value:producerB)observer.sendCompleted()lettersObserver.send(value:"a") // prints "a"numbersObserver.send(value:"1") // prints "1"lettersObserver.send(value:"b") // prints "b"numbersObserver.send(value:"2") // prints "2"lettersObserver.send(value:"c") // prints "c"numbersObserver.send(value:"3") // prints "3"

2 .concetConcat
策略是将内部的SignalProducer排序。外层的producer是立刻被started。随后的producer直到前多少个发送实现后才会start。一有战败立刻传到外层。

let (signalA, lettersObserver) = Signal<Any, NoError>.pipe()let (signalB, numberObserver) = Signal<Any, NoError>.pipe() let (siganl, observer) = Signal<Signal<Any, NoError>, NoError>.pipe() siganl.flatten.observeValues {  in print("value: \}observer.send(value: signalA)observer.send(value: signalB)observer.sendCompleted() lettersObserver.send(value: "dddd")//ddddnumberObserver.send(value: 33) //不打印 lettersObserver.send(value: "sss")//ssslettersObserver.send(value: "ffff")//fffflettersObserver.sendCompleted()//要前一个信号执行完毕后,下一个信号才能被订阅numberObserver.send(value: 44)// 44

3 .Latest.latest只接收最新进来的不胜流的值。

let (signalA, lettersObserver) = Signal<Any, NoError>.pipe()let (signalB, numberObserver) = Signal<Any, NoError>.pipe() let (siganl, observer) = Signal<Signal<Any, NoError>, NoError>.pipe() siganl.flatten.observeValues {  in print("value: \}observer.send(value: signalA)// observer.send(value: signalB) lettersObserver.send(value: "dddd") //ddddnumberObserver.send(value: 33) //不打印lettersObserver.send(value: "sss") //sssobserver.send(value: signalB)//只接受最近进来的信号numberObserver.send(value: 44) //44lettersObserver.send(value: "ffff") // 不打印

2个缓冲通过 <code> SignalProducer.buffer() </code>
创造,是3个事变的队列,当新非确定性信号发生时,会再也履行队列里的轩然大波。

flatMapError

捕捉2个由SignalProducer产生的失败,然后产生三个新的SignalProducer代替。

 1 let (signal, observer) = Signal<Any, NSError>.pipe()
 2         let error = NSError.init(domain: "domian", code: 0, userInfo: nil)
 3         signal.flatMapError { (value) -> SignalProducer<Any, NoError> in
 4             return SignalProducer<Any, NoError>.init({ () -> String in
 5                 return "sssss"
 6             })
 7             }.observeValues { (value) in
 8                 print(value)
 9         }
10         
11         observer.send(value: "无双")
12         observer.send(value: "鹰眼")
13         observer.send(error: error)

 

结果:

4858.com 37

 


 

 

flatMapError

捕捉三个由SignalProducer发生的败诉,然后爆发叁个新的SignalProducer代替。

 1 let (signal, observer) = Signal<Any, NSError>.pipe()
 2         let error = NSError.init(domain: "domian", code: 0, userInfo: nil)
 3         signal.flatMapError { (value) -> SignalProducer<Any, NoError> in
 4             return SignalProducer<Any, NoError>.init({ () -> String in
 5                 return "sssss"
 6             })
 7             }.observeValues { (value) in
 8                 print(value)
 9         }
10         
11         observer.send(value: "无双")
12         observer.send(value: "鹰眼")
13         observer.send(error: error)

 

结果:

4858.com 38

 


 

 

16.flatMapError

flatMapError捕捉三个由SignalProducer发生的破产,然后产生二个新的SignalProducer代替。

let (signal, observer) = Signal<Any, NSError>.pipe()let error = NSError.init(domain: "domian", code: 0, userInfo: nil)signal.flatMapError {  -> SignalProducer<Any, NoError> in return SignalProducer<Any, NoError>.init -> String in return "sssss" })}.observeValues {  in print} observer.send(value: 3333)observer.send(value: 444)observer.send(error: error)

17.retryretry用于依据钦定次数,在波折时重启SignalProducer。

var tries = 0let limit = 2let error = NSError.init(domain: "domian", code: 0, userInfo: nil) let signal = SignalProducer<String, NSError >.init { (observer, _) in tries += 1 if tries < limit { observer.send(error: error) }else{ observer.send(value: "Success") observer.sendCompleted() }} // retry用于按照指定次数,在失败时重启SignalProducer。signal.on(failed:{e in print("Failure")}).retry.start {  in switch event { case .completed: print("Complete") //判断输出值是否相等 case .value("Success"): print case .interrupted: print("interrupted") case .failed: print default: break }}

和<code> pipe
</code>相似,这么些艺术再次来到2个阅览者。各种发给那几个观看者的风浪会被投入队列。就算这一个缓冲区已经达到创造时约定的多寡,当新的事件发来时,最早的二个会被移出队列。

retry

retry用于依据钦赐次数,在波折时重启SignalProducer

 1 var tries = 0
 2         let limit = 2
 3         let error = NSError.init(domain: "😞我错了,求放过!", code: 0, userInfo: nil)
 4         
 5         let signal = SignalProducer<String, NSError >.init { (observer, _) in
 6             tries += 1
 7             if tries < limit {
 8                 observer.send(error: error)
 9             }else{
10                 observer.send(value: "Success")
11                 observer.sendCompleted()
12             }
13         }
14         
15         // retry用于按照指定次数,在失败时重启SignalProducer。
16         signal.on(failed:{e in
17             print("Failure")
18         }).retry(upTo:3).start { (event) in
19             switch event {
20             case .completed:
21                 print("Complete")
22             //判断输出值是否相等
23             case .value("Success"):
24                 print("ddd")
25             case .interrupted:
26                 print("interrupted")
27             case .failed(error):
28                 print(error)
29             default:
30                 break
31                 
32             }
33         }

结果:

4858.com 39

 

 


 

 

retry

retry用于依照内定次数,在失利时重启SignalProducer

 1 var tries = 0
 2         let limit = 2
 3         let error = NSError.init(domain: "😞我错了,求放过!", code: 0, userInfo: nil)
 4         
 5         let signal = SignalProducer<String, NSError >.init { (observer, _) in
 6             tries += 1
 7             if tries < limit {
 8                 observer.send(error: error)
 9             }else{
10                 observer.send(value: "Success")
11                 observer.sendCompleted()
12             }
13         }
14         
15         // retry用于按照指定次数,在失败时重启SignalProducer。
16         signal.on(failed:{e in
17             print("Failure")
18         }).retry(upTo:3).start { (event) in
19             switch event {
20             case .completed:
21                 print("Complete")
22             //判断输出值是否相等
23             case .value("Success"):
24                 print("ddd")
25             case .interrupted:
26                 print("interrupted")
27             case .failed(error):
28                 print(error)
29             default:
30                 break
31                 
32             }
33         }

结果:

4858.com 40

 

 


 

 

18.continuousTextValues

usernameTextField.reactive正是把usernameTextField变成可响应的,而continuousTextValues正是text值的随机信号。

self.nameTF.reactive.continuousTextValues.observe {  in print}

<code> Observer </code>是指其余等待从复信号中接到事件的东西。

continuousTextValues

usernameText菲尔德.reactive就是把usernameTextField变成可响应的,而continuousTextValues就是text值的时限信号。

1 self.nameTF.reactive.continuousTextValues.observe { (value) in
2   print(value)
3 } 

结果:

 


 

 

continuousTextValues

usernameTextField.reactive正是把usernameTextField变成可响应的,而continuousTextValues正是text值的频限信号。

1 self.nameTF.reactive.continuousTextValues.observe { (value) in
2   print(value)
3 } 

结果:

 


 

 

1玖.按钮点击事件和别的事件转能量信号

self.loginBtn.reactive.controlEvents(.touchUpInside).observe {  in print}

Observers能够由此<code> Signal.observe
</code>大概<code>
SignalProducer.start</code>隐式得到。

按钮点击事件和任何事件转功率信号

1 self.loginBtn.reactive.controlEvents(.touchUpInside).observe { (button) in
2   print("点击按钮")
3 }

 

结果:

 


 

 

按钮点击事件和其余事件转时域信号

1 self.loginBtn.reactive.controlEvents(.touchUpInside).observe { (button) in
2   print("点击按钮")
3 }

 

结果:

 


 

 

20.属性的绑定

<~运算符是提供了两种分化的绑定属性的章程。注意这里绑定的习性必须是
MutablePropertyType类型的。

property <~ signal
将三本本性和随机信号绑定在联合署名,属性的值会依据功率信号送过来的值刷新。property
<~ producer
会运行这么些producer,并且属性的值也会趁机那几个产生的时域信号送过来的值刷新。property
<~
otherProperty将三个属性和另1个属性绑定在一块,那样那么些性子的值会随着源属性的值变化而变化。

var userName: MutableProperty<String?> = MutableProperty<String?>var userPw : MutableProperty<String?> = MutableProperty<String?>var logAction = Action<Void, Void, NoError> { (input: Void) -> SignalProducer< Void , NoError> in return SignalProducer{ (observer, disposable) in observer.send) observer.sendCompleted() }}

self.viewModel!.userName <~ nameTF.reactive.textValuesself.viewModel!.userPw <~ pwTF.reactive.textValuesloginBtn.reactive.pressed = CocoaAction<UIButton>((viewModel?.logAction)!)

动成效 <code> Action
</code>类型表示,指当有输入时会做壹些工作。当动作执行时,会有0个或许多少个值输出;也许会发出二个难倒。

性格的绑定

<~运算符是提供了二种分化的绑定属性的法子。注意那里绑定的质量必须是
MutablePropertyType类型的。

property <~ signal
将2个性子和信号绑定在1块,属性的值会依照功率信号送过来的值刷新。
property <~ producer
会运营这几个producer,并且属性的值也会趁着那几个发生的确定性信号送过来的值刷新。
property <~
otherProperty将3个属性和另多少个属性绑定在同步,那样那天性格的值会随着源属性的值变化而变化。

1 var userName: MutableProperty<String?> = MutableProperty<String?>(nil)
2         var userPw : MutableProperty<String?> = MutableProperty<String?>(nil)
3         var logAction = Action<Void, Void, NoError> { (input: Void) -> SignalProducer< Void , NoError> in
4             return SignalProducer{ (observer, disposable) in
5                 observer.send(value: ())
6                 observer.sendCompleted()
7             }
8         }

 

 

self.viewModel!.userName <~ nameTF.reactive.textValues
self.viewModel!.userPw <~ pwTF.reactive.textValues
loginBtn.reactive.pressed = CocoaAction<UIButton>((viewModel?.logAction)!)

 

demo

 

1 //        <>里面可以是任意类型,它代表属性的类型。
2         let racValue = MutableProperty<Int>(1)
3         
4         racValue.producer.startWithValues { (make) in
5             print(make)
6         }
7         
8         racValue.value = 10

 

结果:

 4858.com 41


 

性格的绑定

<~运算符是提供了三种分裂的绑定属性的方式。注意那里绑定的质量必须是
MutablePropertyType类型的。

property <~ signal
将贰个属性和非功率信号绑定在1块,属性的值会依据时域信号送过来的值刷新。
property <~ producer
会运转这些producer,并且属性的值也会趁机那些发生的复信号送过来的值刷新。
property <~
otherProperty将贰天质量和另伍性子能绑定在1道,那样那天性子的值会随着源属性的值变化而变更。

1 var userName: MutableProperty<String?> = MutableProperty<String?>(nil)
2         var userPw : MutableProperty<String?> = MutableProperty<String?>(nil)
3         var logAction = Action<Void, Void, NoError> { (input: Void) -> SignalProducer< Void , NoError> in
4             return SignalProducer{ (observer, disposable) in
5                 observer.send(value: ())
6                 observer.sendCompleted()
7             }
8         }

 

 

self.viewModel!.userName <~ nameTF.reactive.textValues
self.viewModel!.userPw <~ pwTF.reactive.textValues
loginBtn.reactive.pressed = CocoaAction<UIButton>((viewModel?.logAction)!)

 

demo

 

1 //        <>里面可以是任意类型,它代表属性的类型。
2         let racValue = MutableProperty<Int>(1)
3         
4         racValue.producer.startWithValues { (make) in
5             print(make)
6         }
7         
8         racValue.value = 10

 

结果:

 4858.com 42


 

Action用来处理用户交互时做一些拍卖很有利,比如当多个按钮点击时那种动作。Action也得以和1特性格自动关联disabled。比如当四个UI控件的关联Action被安装成disabled时,这些控件也会disabled。

方法调用拦截

当您想获取到某些方法被调用的风浪,比如UIViewController的ViewwillAppear事件

 1 func racsTest() {
 2         self.reactive.trigger(for: #selector(UIViewController.viewWillAppear(_:))).observeValues { () in
 3             
 4             print("viewWillAppear被调用了")
 5             
 6         }
 7         
 8     }
 9     
10     override func viewWillAppear(_ animated: Bool) {
11         print("------------------------------>>>>")
12     }

 

结果:

4858.com 43

 


 

 

方法调用拦截

当你想获取到有些方法被调用的事件,比如UIViewController的ViewwillAppear事件

 1 func racsTest() {
 2         self.reactive.trigger(for: #selector(UIViewController.viewWillAppear(_:))).observeValues { () in
 3             
 4             print("viewWillAppear被调用了")
 5             
 6         }
 7         
 8     }
 9     
10     override func viewWillAppear(_ animated: Bool) {
11         print("------------------------------>>>>")
12     }

 

结果:

4858.com 44

 


 

 

为了和NSControl和UIControl交互,RAC提供了<code> CocoaAction
</code>类型能够桥接到OC下使用

SignalProducer

SignalProducer:非信号产生器,能够发生多少个连续信号,并且能够用在操作(operation)和任务(task)中,比如互联网请求,并且每回调用start()函数将会创造三个主题的操作(operation),确认保障时域信号接收者能收到功率信号。

 上述代码能够变更为,调用start函数,触发相应的操作。其触发函数,只可以调用start

 1 let userSignal = textField.reactive.continuousTextValues.map { (str) -> Bool in
 2             print("userSignal:\(str?.count ?? 0)")
 3             return str!.count == 6
 4         }
 5         let passSignal = pasField.reactive.continuousTextValues.map { (str) -> Bool in
 6             print("passSignal:\(str?.count ?? 0)")
 7             return str!.count == 6
 8         }
 9         
10         userSignal.combineLatest(with: passSignal).map { $0 && $1 }.map { (value) -> String in
11             print("--->value:\(value)")
12             return value ? "UIColor.green" : "UIColor.lightGray"
13             }.producer.start { (signal) in
14                 print("信号的值是:\(signal.event.value ?? "")")
15         }

4858.com 45

结果:

4858.com 46

 

SignalProducer

SignalProducer:功率信号发生器,能够生出多个时限信号,并且能够用在操作(operation)和职务(task)中,比如互联网请求,并且每一趟调用start()函数将会创造四在那之中坚的操作(operation),确定保障连续信号接收者能吸收接纳能量信号。

 上述代码能够变更为,调用start函数,触发相应的操作。其触发函数,只可以调用start

 1 let userSignal = textField.reactive.continuousTextValues.map { (str) -> Bool in
 2             print("userSignal:\(str?.count ?? 0)")
 3             return str!.count == 6
 4         }
 5         let passSignal = pasField.reactive.continuousTextValues.map { (str) -> Bool in
 6             print("passSignal:\(str?.count ?? 0)")
 7             return str!.count == 6
 8         }
 9         
10         userSignal.combineLatest(with: passSignal).map { $0 && $1 }.map { (value) -> String in
11             print("--->value:\(value)")
12             return value ? "UIColor.green" : "UIColor.lightGray"
13             }.producer.start { (signal) in
14                 print("信号的值是:\(signal.event.value ?? "")")
15         }

4858.com 47

结果:

4858.com 48

 

1个属性表现为<code> PropertyType </code>协议,
保存3个值,并且会将以后历次值的更动公告给观望者们。

property的当前值能够通过获取<code> value
</code>获得。<code> producer
</code>重回叁个会直接发送值变化时域信号生成者(signal producer ),

<code> <~
</code>运算符是提供了二种分化的绑定属性的法子。注意这里绑定的品质必须是<code>
MutablePropertyType </code>类型的。

  • <code> property <~ signal </code>
    将3天性质和复信号绑定在一块,属性的值会依据确定性信号送过来的值刷新。
  • <code> property <~ producer </code>
    会运维那一个producer,并且属性的值也会趁着这些暴发的时域信号送过来的值刷新。
  • <code> property <~ otherProperty
    </code>将三特性格和另一特个性绑定在1块,那样那一个脾性的值会随着源属性的值变化而生成。

<code> DynamicProperty </code>
类型用于桥接OC的渴求KVC或然KVO的API,比如<code> NSOperation
</code>。要指示的是绝超越百分之二十五AppKit和UIKit的天性都不协理KVO,所以要观望它们值的变化须求经过其余的建制。比较<code>
DynamicProperty </code>要事先使用 <code> MutablePropertyType
</code>类型。

disposable表现为<code> Disposable </code>
协议,用于内部存款和储蓄器管理和假释销毁。

当你运营三个signal
producer,3个disposable会被重临。能够用来被调起者撤销已经起步的signal
producer(比如后台线程的拍卖,网络请求等),清除暂且能源,发送三个末段的<code>
Interrupted </code>事件给它创设的连续信号。

阅览2个功率信号也会回来一个disposable。调用后就不会再接过那一个非频限信号发过来变化的值,但是那对复信号本身不会发生影响。

越多关于销毁的信息查阅那份文书档案:RAC Design Guidelines.

调度器,类型是<code> SchedulerType </code> 协议,
是二个系列化的要被实践的职责队列恐怕是壹组向外输出的结果。

信号和时限信号生成者能够依据陈设好的先后发送事件到叁个点名的
scheduler。复信号生产者还足以在内定的调度器上被运维。

scheduler很像GCD,不过scheduler可以被销毁(通过Disposable),而且连接一而再举办。由于
ImmediateScheduler会引发这一个,
scheduler不提供同步的操作。那样可防止止出现死锁,还鼓励采用时域信号的操作符而不是blocking
work。scheduler也有点像<code>NSOperationQueue</code>,
不过scheduler不容许职分依据另1个调度器而变更各样。

迎接关心自身的今日头条:@没典故的卓同学

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有