澳门新萄京官方网站-www.8455.com-澳门新萄京赌场网址

澳门新萄京官方网站文书档案翻译

2019-06-29 作者:www.8455.com   |   浏览(148)

RAC类关系图:

澳门新萄京官方网站 1


 

RAC类关系图:

澳门新萄京官方网站 2


 

文章出自此链接

原文:Framework Overview

文档地址:Basic Operators

RAC 信号源:

澳门新萄京官方网站 3


RAC 信号源:

澳门新萄京官方网站 4


最近再重新学习swift,从OC的RAC转到Swift的RAC方法调用大变样,各种的不适应。

我翻译的RAC4的文档ReactiveCocoa 4 官方文档翻译ReactiveCocoa 4 文档翻译:基本操作符ReactiveCocoa 4 文档翻译:基本操作符ReactiveCocoa 4 文档翻译:框架组成介绍ReactiveCocoa 4 文档翻译:兼容Objective-CReactiveCocoa 4 文档翻译--设计指南:事件的规范ReactiveCocoa 4 文档翻译:设计指南:信号的规范[翻译]ReactiveCocoa 4 最佳实践

本文将介绍:combineLatest、zip、flatten( .Merge, .Concat, .Latest)、flatMapError、retry、mapError、promoteErrors 操作符。

 需要导入的头文件:

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

框架组成:1.事件2.监听器3.清洁者(Disposable)4.信号5.管道:6.信号生产者:(Signal Producers)7.缓冲:8.动作:9.属性:(Properties)10.调度器:(Schedulers)

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

本文将以整个框架的高度介绍RAC框架中的主要组成元素,尝试说明它们是怎么组成在一起工作和各自的职责。这会有助于你学习新模块和查找相关详细说明的文档。关于RAC的例子和应该怎么使用可以查看这两个文档:ReactiveCocoa 4 官方文档翻译:ReadMe 或者 Design Guidelines。

我翻译的RAC4的文档ReactiveCocoa 4 官方文档翻译ReactiveCocoa 4 文档翻译:基本操作符ReactiveCocoa 4 文档翻译:基本操作符ReactiveCocoa 4 文档翻译:框架组成介绍ReactiveCocoa 4 文档翻译:兼容Objective-CReactiveCocoa 4 文档翻译--设计指南:事件的规范ReactiveCocoa 4 文档翻译:设计指南:信号的规范[翻译]ReactiveCocoa 4 最佳实践

冷信号

 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)

结果:

澳门新萄京官方网站 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)

结果:

澳门新萄京官方网站 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> Event </code>类型表示, 表示某些事情已经发生。 在RAC中事件是传播(center-piece of communication)的核心。 一个事件可能是button的一次点击,从API返回的一些信息,一个错误的发生,或者一个长时间操作完成了。无论如何,一些东西产生事件,然后通过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()

结果: 澳门新萄京官方网站 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()

结果: 澳门新萄京官方网站 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>是一个枚举类型,可能有四种值(Next中有值,其他三种表示结束):

<code> combineLatest </code>函数可以把几个事件流最新的值组合成一个新的事件流。合成后的新事件流只有在收到每个合成流的至少一个值后才会发送出去。接着就会把每个流的最新的值一起输出。<pre><code>let (numbersSignal, numbersObserver) = Signal<Int, NoError>.pipe()

文本框监听

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

 

结果:

澳门新萄京官方网站 9


 

文本框监听

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

 

结果:

澳门新萄京官方网站 10


 

3.监听文本框

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>代表有一个新的值从源产生。
  • <code> Failed </code>说明在信号源完成前发生了一个错误。事件会被当做一个类型为<code> ErrorType </code>的参数,一种在事件中声明过的表示已知错误的类型。如果这个错误没有被声明许可过,可以用<code> NoError </code>表示。
  • <code> Completed </code>说明事件已经成功结束。不会再有值发送出来。
  • <code> Interrupted </code>说明事件被取消了,意味着操作既没有成功也没有失败。

let (lettersSignal, lettersObserver) = Signal<String, NoError>.pipe()

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

方法一:

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

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

            }.observeValues { (count) in

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

        }

输入: Hello123

结果为:

澳门新萄京官方网站 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")

结果为:

澳门新萄京官方网站 12


 

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

方法一:

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

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

            }.observeValues { (count) in

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

        }

输入: Hello123

结果为:

澳门新萄京官方网站 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")

结果为:

澳门新萄京官方网站 14


 

4.信号合并

合成后的新事件流只有在收到每个合成流的至少一个值后才会发送出去。接着就会把每个流的最新的值一起输出。

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() }

一个信号, 用 <code> Signal </code>类型表示,是一连串随着时间发出的可以被观察的事件。

let signal = combineLatest(numbersSignal, lettersSignal)

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 

 

方法二:

 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中的信号都要被订阅才能激活,意味着如果是一个流的第N个元素,一定要等到另外一个流第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会把它们推送给每个观察者。所有的观察者都会同时接受到事件。

signal.observeNext { next in print("Next: }

信号合并

合成后的新事件流只有在收到每个合成流的至少一个值后才会发送出去。接着就会把每个流的最新的值一起输出。

 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()

结果:

澳门新萄京官方网站 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()

结果:

澳门新萄京官方网站 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。观察一个信号不会触发其他副作用。换句话说,事件是源驱动,基于推送,观察者在整个生命周期里不会受到到任何影响。当观察一个信号时,用户只能按照顺序处理信号里的事件。不能随意访问信号里的事件。

signal.observeCompleted { print("Completed") }

信号联合

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")

结果:

澳门新萄京官方网站 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")

结果:

澳门新萄京官方网站 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可以一次处理多个信号源。操作符只能在Next事件中才能使用。(具体操作符可以参考我翻的这篇:ReactiveCocoa 4 文档翻译:基本操作符)

numbersObserver.sendNext // nothing printed

调度器

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         }

结果:澳门新萄京官方网站 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         }

结果:澳门新萄京官方网站 20


 

8.KVO

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

信号的整个生命周期有一组Next事件组成,最后是一个终结事件,可能是Failed, Completed, 或者Interrupted中的任一个。终结事件没有被包含在事件的值里,他们需要被单独处理。

numbersObserver.sendNext // nothing printed

通知

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         }

结果:

澳门新萄京官方网站 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         }

结果:

澳门新萄京官方网站 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的代码转变到信号世界里特别有用。

lettersObserver.sendNext // prints

KVO 

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

 输入:Hello

注意:输一个字符,Return 一下,否则监听不到

结果:

澳门新萄京官方网站 23

 


 

KVO 

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

 输入:Hello

注意:输一个字符,Return 一下,否则监听不到

结果:

澳门新萄京官方网站 24

 


 

10.on

可以通过 on来观察signal,生成一个新的信号,即使没有订阅者也会被触发。和 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简化成发送事件给观察者。同时信号可以被返回,隐藏回调里的具体实现。

澳门新萄京官方网站文书档案翻译。numbersObserver.sendNext // prints

迭代器

 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         }

结果:

澳门新萄京官方网站 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         }

结果:

澳门新萄京官方网站 26


 

11.Map

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

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")

一个信号生产者,以 <code> SignalProducer </code>类型表示,创建信号并且产生副作用。

numbersObserver.sendCompleted() // nothing printed

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()

结果:

澳门新萄京官方网站 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()

结果:

澳门新萄京官方网站 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>调用后会创建一个新的操作,允许发起者观察结果。通过<code> startWithSignal()</code>可以访问到产生的信号,允许被多次观察。

lettersObserver.sendNext // prints

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()

结果:

澳门新萄京官方网站 29


 

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()

结果:

澳门新萄京官方网站 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>这种行为的不同,每次从同一个信号生产者可能会得到不同顺序或者版本的事件,甚至整个流可能完全不同。不像一个普通的信号,直到有一个观察者被添加才会开始启动,每次都会为新添加的观察者重新工作一次。

lettersObserver.sendNext // prints

flatten

flatten 将一个事件流里的事件流变成一个单一的事件流。新的事件流的值按照指定的策略(FlattenStrategy)由内部的事件流的值组成。 被压平的值按照会变成外层的流的类型。比如:一个SignalProducers里的Signal,被flatten后的类型是SignalProducers。


 

flatten

flatten 将一个事件流里的事件流变成一个单一的事件流。新的事件流的值按照指定的策略(FlattenStrategy)由内部的事件流的值组成。 被压平的值按照会变成外层的流的类型。比如:一个SignalProducers里的Signal,被flatten后的类型是SignalProducers。


 

14.flatten

flatten 将一个事件流里的事件流变成一个单一的事件流。新的事件流的值按照指定的策略(FlattenStrategy)由内部的事件流的值组成。被压平的值按照会变成外层的流的类型。比如:一个SignalProducers里的Signal,被flatten后的类型是SignalProducers。

开启一个信号生产者会返回一个<code> disposable </code>,用了中断或者取消(interrupt/cancel)这个信号生产者的工作。和信号一样,信号生产者可以被操作符比如map,filter等操作。每个信号的操作符都可以通过“lifted”迁移后在信号生产者上使用。而且,还有几个特有的操作符用了控制工作什么时候开始和怎么运行,比如<code> times </code>。

lettersObserver.sendCompleted() // prints "Completed"</code></pre><code> combineLatestWith </code>操作符也是同样的工作模式。

合并

简单的说就是merge按照时间顺序组成,concat则是按照里面整个流顺序组合。latest澳门新萄京官方网站文书档案翻译。是只记录最近一次过来的值的那个流。

 .1 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"

结果: 

澳门新萄京官方网站 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

结果:

澳门新萄京官方网站 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") // 不打印

 

结果:

澳门新萄京官方网站 33


 

合并

简单的说就是merge按照时间顺序组成,concat则是按照里面整个流顺序组合。latest是只记录最近一次过来的值的那个流。

 .1 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"

结果: 

澳门新萄京官方网站 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

结果:

澳门新萄京官方网站 35

 

.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") // 不打印

 

结果:

澳门新萄京官方网站 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") // 不打印

一个缓冲通过 <code> SignalProducer.buffer() </code> 创建,是一个事件的队列,当新信号产生时,会重新执行队列里的事件。

澳门新萄京官方网站 37combineLatest

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)

 

结果:

澳门新萄京官方网站 38

 


 

 

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)

 

结果:

澳门新萄京官方网站 39

 


 

 

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>相似,这个方法返回一个观察者。每个发给这个观察者的事件会被加入队列。如果这个缓冲区已经达到创建时预定的数量,当新的事件发来时,最早的一个会被移出队列。

可以看出在都收到两个事件流的值,1和A后,开始输出。接着每有一个值输入,就根据两个流最近输入的值输出值。

retry

retry用于按照指定次数,在失败时重启SignalProducer

 1 var tries = 0
 2         let limit = 2
 3         let error = NSError.init(domain: " 
		

本文由澳门新萄京官方网站发布于www.8455.com,转载请注明出处:澳门新萄京官方网站文书档案翻译

关键词: