ReactiveSwift(下)ReactiveSwift(上)

SignalProducer

SignalProducer是ReactiveSwift中冷信号的兑现, 是第二种植发送事件的途径.

        热信号是挪在的波发生器, 相对应之,
冷信号则是休眠中的事件来器. 也就是说冷信号用一个提醒操作,
然后才能够发送事件, 而这个提示操作就是订阅它. 因为订阅后才发送事件, 显然,
冷信号不设有时机早晚的题材. 仍为春晚举例:

        冷信号相当给春晚之视频文件而未是现场直播, 正常状况下,
视频文件肯定是匪会见自动播放的, 但你如同双击,
它就受启动广播然后输出节目了.

//1. 通过SignalProducer.init(startHandler: (Observer, Lifetime) -> Void)创建SignalProducer

let producer = SignalProducer { (innerObserver, lifetime) in

lifetime.observeEnded({

print(“信号无效了 你得以这边开展一些清理工作”)

})

//2. 于外面发送事件

innerObserver.send(value: 1)

innerObserver.send(value: 2)

innerObserver.sendCompleted()

}

//3. 创一个观察者封装事件处理逻辑

let outerObserver = Signal.Observer(value: { (value) in

print(“did received value: (value)”)

})

//4. 添加观察者到SignalProducer

producer.start(outerObserver)

输出: did received value: 1

did received value: 2

信号无效了 你得于这边开展有清理工作

typealias Producer = ReactiveSwift.SignalProducer

let producer = Producer { (innerObserver, _) in

//没什么想清理的

innerObserver.send(value: 1)

innerObserver.send(value: 2)

innerObserver.sendCompleted()

}

producer.startWithValues { (value) in

print(“did received value: (value)”)

}

producer.startWithFailed(action: )

producer.startWithResult(action: )

producer.startWithXXX…各种便利函数

与Signal的订阅方式若有同智, 只是名换了瞬间,
Signal.observeXXX换成了SignalProducer.startXXX.

            都是事件发生器,
所以API方面Signal和SignalProducer都是同的,方的map, on, merge,
comblinelast…等等, SignalProducer也产生雷同客, 作用也都同一
,
我就算非多说了, 这里大概吃点儿段子代码说说可能撞的坑

func fetchData(completionHandler: (Int, Error?) -> ()) {

print(“发起网络要”)

completionHandler(1, nil)

}

let producer = Producer {[unowned self] (innerObserver, _) in

self.fetchData(completionHandler: { (data, error) in

innerObserver.send(value: data)

innerObserver.sendCompleted()

})

}

producer.startWithValues { (value) in

print(“did received value: (value)”)

}

producer.startWithValues { (value) in

print(“did received value: (value)”)

}

出口: 发起网络要

did received value: 1

提倡网络要

did received value: 1

或者你只是想少个观察者共享一差网络要带回的Event,
但事实上这里会起两软网络要, 但这不是一个bug, 这是一个feature.

SignalProducer的一个特性是,
每次让订阅就见面履同样潮初始化时保留的闭包.

为此如果您出相近一不行执行, 多处订阅的要求,
你当选Signal而未是SignalProducer. 所以, 符合要求的代码可能是这么:

let signalTuple = NSignal.pipe()

signalTuple.output.observeValues { (value) in

print(“did received value: (value)”)

}

signalTuple.output.observeValues { (value) in

print(“did received value: (value)”)

}

self.fetchData { (data, error) in

signalTuple.input.send(value: data)

signalTuple.input.sendCompleted()

}

输出: 发起网络要

did received value: 1

did received value: 1

            到目前为止, 示例代码中让到之且是NoError类型的信号,
在其实付出被, 这明确是勿可能的, 毕竟错误是不可逆转的.
通常咱们的档次会声明一个近似APIError的谬误类型来代表这些不当,
所以你可能会见出诸如此类的扬言:    

structAPIError: Swift.Error {

let code: Int

var reason =””

}

typealias NSignal = ReactiveSwift.Signaltypealias 

 APISignal = ReactiveSwift.Signaltypealias

 Producer = ReactiveSwift.SignalProducertypealias

 APIProducer = ReactiveSwift.SignalProducer

诸如此类的宣示很好, 能给ReactiveSwift写起来像RXSwift一样”简洁”.
但此处用添加下面的代码才能够重好之做事:

extension SignalProducer where Error == APIError {

@discardableResult

func startWithValues(_ action: @escaping (Value) -> Void) -> Disposable {

returnstart(Signal.Observer(value: action))

}

}

        这是坐默认的SignalProducer是从来不startWithValues函数的,
ReactiveSwift会在Extension里受她长startWithValues函数,
但是就只针对NoError有效, 所以当您以自定义Error时, 请记得加上类似的代码.  
 

Observer

Observer信息的处理逻辑封装, Observer的要害代码如下:

//Observer.swift

public final class Observer {   

 public typealias Action = (Event) -> Void  

private let _send: Action            

 public init(_ action: @escaping Action) {        self._send = action        …    }     

public func send(_ event: Event) {        _send(event)    }                  

public func send(value: Value) {        _send(.value(value))    }                  
 

public func sendXXX() //其实都是send(_ event: Event)}

Observer内部维持了一个甩卖Event的闭包,
初始化Observer就是在安这个闭包,
而调用Observer.send则是以尽之闭包.

**需要注意的接触: Observer封装了Event的拍卖逻辑.
**


**Signal **

起矣音讯之载体与信的拍卖逻辑, 接下来需要之是: 将信息发送出去.

以ReactiveSwift中, 想如果发送信息共有四种途径, 这里我们事先介绍第一栽:
Signal.(事实上, 四种植途径最终都是经Signal来就的, 所以, 其实只出一样种.)

Signal是ReactiveSwift中热信号的兑现, “热”的意是其是一直走在的,
会主动将应运而生的轩然大波Event向他发送, 而不见面当交有人订阅后才起发送.
这象征一旦订阅的火候晚于发送的火候,
那么订阅者是免见面接订阅时机之前的风波之.

举个栗子: 春晚现场直播从晚8碰一直播至12沾,
这段日子出现的节目就是是Value事件, 12接触同样到起的哪怕是Completed事件.
很显然, 不管有没有人看春晚,  春晚现场都不关注, 节目来了不畏直达,
时间一到就散. 但如果你想看直播, 最好之火候当然是8碰, 若是9点才打开电视机,
那9点之前的剧目而必就是去了.

Signal的使用:

note: 这里的Value和Error都是泛型, 你待以创立的时光进行点名

//public static func pipe(disposable: Disposable? = nil) -> (output: Signal, input: Observer)

let signalTuple = Signal.pipe()

let (signal, observer) = Signal.pipe()

普通, 你应有就经过Signal.pipe()函数来初始化一个热信号.
这个函数会返回一个元组, 元组的率先个价是output(类型为Signal),
第二单价是input(类型也Observer). 我们透过output来订阅信号,
通过input来为信号发生信息.

需要注意的接触:
output的意向是治本信号状态并保存由订阅者提供的Observer对象(Observer._send封装了Event的处理逻辑),
而input的来意则是当收取到Event后挨家挨户执行这些吃封存之Observer._send.

来拘禁无异截订阅Signal的基本功代码:

func bindSignal2_1(){

//1.创建signal(output)和innerObserver(input)

let (signal, innerObserver) = Signal.pipe()

//2.创建Observer

let outerObserver1 = Signal.Observer(value: { (value) in

print(“did received value: (value)”)

})

//2.还是开创Observer

let outerObserver2 = Signal.Observer { (event) in

switch event {

case let .value(value):

print(“did received value: (value)”)

default: break }

}

signal.observe(outerObserver1)//3.向signal中添加Observer
signal.observe(outerObserver2)//3.还是向signal中添加Observer

innerObserver.send(value:
1)//4.通向signal发生信息(执行signal保存之持有Observer对象的Event处理逻辑)

innerObserver.sendCompleted()//4.还是执向signal发生信息

}

        实际支付中我们一定不见面如此描绘, 太繁琐了. 它的义在告诉各位:
1)每订阅一涂鸦Signal实际上就是以向阳Signal中补充加一个Observer对象.
2)即使每次订阅信号的处理逻辑都是平等的,
但它们还是全两样之的片单Observer对象.        

将地方的代码改的简单一点:

typealias NSignal = ReactiveSwift.Signaloverride 

func viewDidLoad() {

        super.viewDidLoad() 

       //1.创建signal(output)和innerObserver(input)

        let (signal, innerObserver) = NSignal.pipe()

                         
 signal.observeValues { (value) in   //2&3.开立Observer并添加到Signal中            print(“did received value: (value)”)        }        signal.observeValues { (value) in   //2&3.还是创造Observer并添加到Signal中            print(“did received value: (value)”)        }                 innerObserver.send(value: 1) //4. …        innerObserver.sendCompleted() //4. …}

        介绍下Signal.observeValues, 这是Signal.observe的一个造福函数,
作用是创立一个
只处理Value事件的Observer并添加暨Signal中,
类似之还有
只处理Failed事件的Signal.observeFailed和负有事件还能处理的**Signal.observeResult.

热信号相关代码:

typealias NSignal = ReactiveSwift.Signal

//ViewModel.swift

class ViewModel {

    let signal: NSignal    

    let innerObserver: NSignal.Observer       

    init() { (signal, innerObserver) = NSignal.pipe() }

//View1.swift

class View1 {

   func bind(viewModel: ViewModel) {

       viewModel.signal.observeValues { (value) in 

           print(“View1 received value: (value)”)

        }

    }

//View2.swift

class View2 {

    func bind(viewModel: ViewModel) {

        viewModel.signal.observeValues { (value) in

            print(“View2 received value: (value)”)

        }

    }

//View3.swift

class View3 {

    func bind(viewModel: ViewModel) {

          viewModel.signal.observeValues { (value) in

            print(“View3 received value: (value)”)

        }

        viewModel.signal.observeInterrupted { 

           print(“View3 received interrupted”)

        }

    }}

 override func viewDidLoad() {

       super.viewDidLoad()

        let view1 = View1() 

       let view2 = View2()

        let view3 = View3() 

       let viewModel = ViewModel()

       view1.bind(viewModel: viewModel)//订阅时机较早        

       viewModel.innerObserver.send(value: 1) 

        view2.bind(viewModel: viewModel)//订阅时机较晚          

        viewModel.innerObserver.send(value: 2)        

        viewModel.innerObserver.sendCompleted()//发送一个非Value事件 信号无效

         view3.bind(viewModel: viewModel)//信号无效后才订阅        

        viewModel.innerObserver.send(value: 3)//信号无效后发送事件    }

        view2的订阅时间晚于value1的殡葬时间,
所以view2收不交value1对应之轩然大波,
这有遥相呼应上面我说的热信号并无关注订阅者的状态, 一旦产生事件便会发送.

        第二片段则是Signal自身之风味:
收到任何非Value的轩然大波后信号就无效了.
所以您晤面看到虽然view1和view2的订阅都早于value3的发送时间,
但因为value3在信号发送前先发送了completed事件,
所以view1和view2都非会见接受value3事件, 同理,
view3也无见面接value3事件(它就会吸纳一个interrupted, 如果它关注的语).


KVO

public func signal(forKeyPath keyPath: String) -> Signal

tableView: UITableView

dynamic var someValue = 0

 reactive.signal(forKeyPath: “someValue”).observeValues { [weak self] (value) in      //code}

 tableView.reactive.signal(forKeyPath: “contentSize”).observeValues {[weak self] (contentSize) in

    if
 let contentSize = contentSize as? CGSize,        let strongSelf = self {

                 let isHidden = contentSize.height < strongSelf.tableView.height 

               
DispatchQueue.main.asyncAfter(deadline: DispatchTime.now(),

               
execute: {            strongSelf.tableView.mj_footer.isHidden = isHidden

        })    }}

        KVO的Reactive版本, 对于NSObject的子类可以直接行使,
对于Swift的本原生类需要添加dynamic修饰.


Map

let (signal, innerObserver) = NSignal.pipe()

signal.map { return “xxx” + String($0) } 

//map就不说明了

.observeValues { (value) in

            print(value)

        } 

        innerObserver.send(value: 1)innerObserver.sendCompleted()

打印:

xxx1


On:

public func on(

        event: ((Event) -> Void)? = nil,

        failed: ((Error) -> Void)? = nil, 

        completed: (() -> Void)? = nil,

        interrupted: (() -> Void)? = nil,

        terminated: (() -> Void)? = nil,  

       disposed: (() -> Void)? = nil,

        value: ((Value) -> Void)? = nil) -> Signal

D😈emo:

let (signal, innerObserver) = NSignal.pipe()

signal.on( value: { (value) in

    print(“on value: (value)”)

}).observeValues { (value) in

    print(“did received value: (value)”

)}

 innerObserver.send(value: 1)

innerObserver.sendCompleted()

 打印:

 on value: 1

  did received value: 1

        on: 在信号发送事件和订阅者收到事件中插入一段事件处理逻辑,
你可以管其作为map的简洁版. (这个函数的参数很多, 但默认都有于nil,
所以你仅仅待关怀自己索要的局部即可,
比如这里自己特想以Value事件间插入逻辑)


take(until:)

public func take(until trigger: Signal) -> Signal

let (signal, innerObserver) = NSignal.pipe()

let (takeSignal, takeObserver) = NSignal.pipe()signal.take(until: takeSignal).observeValues { (value) in

    print(“received value: (value)”)

}

 innerObserver.send(value: 1)

innerObserver.send(value: 2)

 takeObserver.send(value: ())

innerObserver.send(value: 3) 

takeObserver.sendCompleted()

innerObserver.sendCompleted()

 打印: received value: 1      received value: 2

        take(until:): 在takeSignal发送Event之前,
signal可以正常发送Event, 一旦takeSignal开始发送Event, signal就住发送,
takeSignal相当给一个休标志位.


take(first:)

publicfunc take(first count: Int) -> Signal

let (signal, innerObserver) = NSignal.pipe()

signal.take(first: 2).observeValues { (value) in

    print(“received value: (value)”)

}

innerObserver.send(value: 1)

innerObserver.send(value: 2)

innerObserver.send(value: 3)

innerObserver.send(value: 4)

innerObserver.sendCompleted()

打印: received value: 1   received value: 2

take(first:): 只抱最初N次的Event.

仿佛之还有signal.take(last: ): 只取得最后N次的Event.


参考资料:
ReactiveSwift(上)

Leave a Comment.