RAC类关系图：

RAC 信号源：

需要导入的头文件：

 import ReactiveCocoa

 import Result

 import ReactiveSwift

冷信号

  //1.冷信号

         let producer = SignalProducer<String, NoError>.init { (observer, _) in

             print("新的订阅，启动操作")

             observer.send(value: "Hello")

             observer.send(value: "World")

             observer.sendCompleted()

         }

         //创建观察者 (多个观察者观察会有副作用)

         let sub1 = Signal<String, NoError>.Observer(value: { (value) in

             print("观察者1接受信号\(value)")

         })

         let sub2 = Signal<String, NoError>.Observer(value: { (value) in

             print("观察者2接受信号\(value)")

         })

         //观察者订阅信号

         print("观察者1订阅信号")

         producer.start(sub1)

         print("观察者2订阅信号")

         producer.start(sub2)

结果：

热信号

 //        热信号 (通过管道创建)

         let (signalA, observerA) = Signal<String, NoError>.pipe()

         let (signalB, observerB) = Signal<Int, NoError>.pipe()

         Signal.combineLatest(signalA,signalB).observeValues { (value) in

             print("两个热信号收到的值\(value.0) + \(value.1)")

         }

         //订阅信号要在send之前

         signalA.observeValues { (value) in

             print("signalA : \(value)")

         }

         observerA.send(value: "sssss")

         //        observerA.sendCompleted()

         observerB.send(value: )

         //        observerB.sendCompleted()

         observerB.send(value: )

         //不sendCompleted和sendError 热信号一直激活

         //        observerB.sendCompleted()

结果：

文本框监听

 func racsTest() {

         textField.reactive.continuousTextValues.observeValues { (text) in

             print("值为：\(text ?? "")")

         }

     }

结果：

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

方法一：

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

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

            }.observeValues { (count) in

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

        }

输入： Hello123

结果为：

方法二：

 let (signal, observer) = Signal<String, NoError>.pipe()

         signal.map { (string) -> Int in

             return string.lengthOfBytes(using: .utf8)

             }.observeValues { (length) in

                 print("长度length: \(length)")

         }

         observer.send(value: "")

         observer.send(value: "some")

结果为：

Filter函数可以按照之前预设的条件过滤掉不满足的值

方法一：

 textField.reactive.continuousTextValues.filter { (text) -> Bool in

             return text!.characters.count > 

             }.observeValues { (text) in

                 print(text ?? "")

         }

输入： 1234

结果：

1234

方法二：

 let (signal, observer) = Signal<Int, NoError>.pipe()

         signal.filter { (value) -> Bool in

             return value %  ==

             }.observeValues { (value) in

                 print("\(value)能被2整除")

         }

         observer.send(value: )

         observer.send(value: )

         observer.send(value: )

         observer.send(value: )

结果：

4能被2整除

6能被2整除

信号合并

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

 //        信号合并 两个要被订阅combineLatest 才能被订阅，被订阅后，合并中其中一个sendNext都会激活订阅

         let (signalA, observerA) = Signal<String, NoError>.pipe()

         let (signalB, observerB) = Signal<Array<Any> , NoError>.pipe()

         Signal.combineLatest(signalA, signalB).observeValues { (value) in

             print("合并的信号:\(value)")

         }

         observerA.send(value: "xxx")

         observerA.sendCompleted()

         observerB.send(value: ["sdsd","ddddd"])

         observerB.sendCompleted()

结果：

信号联合

zip中的信号都要被订阅才能激活,意味着如果是一个流的第N个元素，一定要等到另外一个流第N值也收到才会一起组合发出。

 //        信号联合

         let (signalA, observerA) = Signal<String, NoError>.pipe()

         let (signalB, observerB) = Signal<String, NoError>.pipe()

         //两个到需要订阅 才激活zip

         Signal.zip(signalA, signalB).observeValues { (value) in

             print("zip: \(value)")

         }

         observerA.send(value: "")

 //                observerA.sendCompleted()

         observerB.send(value: "")

 //                observerB.sendCompleted()

         observerB.send(value: "cc")

         observerA.send(value: "dd")

结果：

调度器

    QueueScheduler.main.schedule(after: Date.init(timeIntervalSinceNow: )) {

             print("主线程3秒过去了")

         }

         QueueScheduler.init().schedule(after: Date.init(timeIntervalSinceNow: )) {

             print("子线程2秒过去了")

         }

结果：

通知

 //        通知

         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("键盘收起")

         }

结果：

KVO

 let result = self.textField.reactive.producer(forKeyPath: "text")

         result.start { (text) in

             print("----------->\(text)");

         }

输入：Hello

注意：输一个字符，Return 一下，否则监听不到

结果：

迭代器

 //        迭代器

         let array:[String] = ["name1", "name2"]

         var arrayIterator = array.makeIterator()

         while let temp = arrayIterator.next() {

             print(temp)

         }

         //swift系统自带

         array.forEach { (value) in

             print("系统自带：\(value)")

         }

结果：

on

可以通过 on来观察signal，生成一个新的信号，即使没有订阅者也会被触发。
和 observe相似，也可以只观察你关注的某个事件。
需要提到的是 producer要started后才会触发。

 let signal = SignalProducer<String , NoError>.init { (obsever, _) in

             obsever.send(value: "SignalProducer")

             obsever.sendCompleted()

         }

         //可以通过 on来观察signal，生成一个新的信号，即使没有订阅者（sp.start()）也会被触发。

         let sp = signal.on(starting: {

             print("开始")

         }, started: {

             print("结束")

         }, event: { (event) in

             print("Event: \(event)")

         }, failed: { (error) in

             print("error: \(error)")

         }, completed: {

             print("信号完成")

         }, interrupted: {

             print("信号被中断")

         }, terminated: {

             print("信号结束")

         }, disposed: {

             print("信号清理")

         }) { (value) in

             print("value: \(value)")

         }

         sp.start()

结果：

reduce

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

 let (signal, observer) = Signal<Int, NoError>.pipe()

         //reduce后的是聚合的次数

         signal.reduce() { (a, b) -> Int in

             //a是相乘后的值 b是传入值

             print("a:\(a) b:\(b)")

             return a * b

             }.observeValues { (value) in

                 print("输出的值是：\(value)")

         }

         observer.send(value: )

         observer.send(value: )

         observer.send(value: )

         //要注意的是最后算出来的值直到输入的流完成后才会被发送出去。

         observer.sendCompleted()

结果：

flatten

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

合并

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

.1 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(.merge).observeValues { (value) in

             print("value: \(value)")

         }

         observer.send(value: producerA)

         observer.send(value:producerB)

         observer.sendCompleted()

         lettersObserver.send(value:"埃及") // prints "a"

         numbersObserver.send(value:"") // prints "1"

         lettersObserver.send(value:"罗马") // prints "b"

         numbersObserver.send(value:"") // prints "2"

         lettersObserver.send(value:"瑞典") // prints "c"

         numbersObserver.send(value:"") // prints "3"

结果：

.2 Concat 策略是将内部的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(.concat).observeValues { (value) in

             print("value: \(value)")

         }

         observer.send(value: signalA)

         observer.send(value: signalB)

         observer.sendCompleted()

         lettersObserver.send(value: "dddd")//dddd

         numberObserver.send(value: )    //不打印是因为lettersObserver的发送值没有结束，所以 44 能打印出来

         lettersObserver.send(value: "sss")//sss

         lettersObserver.send(value: "ffff")//ffff

         lettersObserver.sendCompleted()

         //要前一个信号执行完毕后，下一个信号才能被订阅

         numberObserver.send(value: )//

结果：

.3 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(.latest).observeValues { (value) in

             print("value: \(value)")

         }

         observer.send(value: signalA)

         //        observer.send(value: signalB)

         lettersObserver.send(value: "dddd")  //dddd

         numberObserver.send(value: )      //不打印

         lettersObserver.send(value: "sss")  //sss

         observer.send(value: signalB)

         //只接受最近进来的信号

         numberObserver.send(value: )  //

         lettersObserver.send(value: "ffff") // 不打印

结果：

flatMapError

捕捉一个由SignalProducer产生的失败，然后产生一个新的SignalProducer代替。

 let (signal, observer) = Signal<Any, NSError>.pipe()

         let error = NSError.init(domain: "domian", code: , userInfo: nil)

         signal.flatMapError { (value) -> SignalProducer<Any, NoError> in

             return SignalProducer<Any, NoError>.init({ () -> String in

                 return "sssss"

             })

             }.observeValues { (value) in

                 print(value)

         }

         observer.send(value: "无双")

         observer.send(value: "鹰眼")

         observer.send(error: error)

结果：

retry

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

 var tries =

         let limit =

         let error = NSError.init(domain: "												

																
最新文章	

						eclipse 快捷键大全
		
						ActiveReport 同一单元格内图片跟文字按条件显示
		
						OAF_开发系列17_实现OAF数组应用Vector / Hashmap / Hashtable / Arraylist（案例）
		
						iTextSharp带中文转换出来的PDF文档显示乱码
		
						BZOJ1015 并查集
		
						PHP中的include和require
		
						ORACLE 表函数实现
		
						十步让 WebForm项目 变为 Mvc项目
		
						网页绘制图表 Google Charts with JavaScript #2 ....与ASP.NET网页结合 (ClientScriptManager.RegisterStartupScript 方法)
		
						Android（java）学习笔记69：JDK5之后的Lock锁的概述和使用
		
						python 零散记录(四) 强调字典中的键值唯一性 字典的一些常用方法
		
						python手记(30)
		
						利用servicestack连接redis
		
						POJ3728 LCA RMQ DP
		
						html 5 video
		
						【算法导论】最小生成树之Kruskal法
		
						使用javamelody进行web监控
		
						php去掉字符串的最后一个字符
		
						使用freemarker生成xml模板
		
						BZOJ2839 : 集合计数 (广义容斥定理)
		
		
	

热门文章	

									SQL查询优化:详解SQL Server非聚集索引（转载）
			
						swift 桥接 Bridging 的创建和使用
			
						js：return [ expression ]，return false，return true，return的区别
			
						Redis所支持的数据结构
			
						MongoDB pymongo模块 删除数据
			
						20180318  一个VS2015运行DataTable问题
			
						DevExpress换肤
			
						C# install-package:&quot;xx&quot;已拥有为“xxx”定义的依赖项
			
						oracle sql小结（主要讲横列转换的例子）decode 以及case
			
						Cell complex单元复合形

巴特西

ReactiveCocoa(II)

RAC类关系图：

RAC 信号源：

需要导入的头文件：

冷信号

热信号

文本框监听

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

Filter函数可以按照之前预设的条件过滤掉不满足的值

信号合并

信号联合

调度器

通知

KVO

迭代器

on

reduce

flatten

合并

flatMapError

retry

最新文章

热门文章

巴特西

ReactiveCocoa(II)

RAC类关系图：

RAC 信号源：

需要导入的头文件：

冷信号

热信号

文本框监听

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

Filter函数可以按照之前预设的条件过滤掉不满足的值

信号合并

信号联合

调度器

通知

KVO

迭代器

on

reduce

flatten

合并

flatMapError

retry

最新文章

热门文章

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