ReactiveCocoa(II)

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