Swift 响应式编程FRP使用RAC学习笔记3

前面介绍了信号，这里介绍一个信号发生器SignalProducer。关于信号发生器的图例可参考自ReactiveCocoa 4 图解之六——信号发生器（SignalProducer）。

冷信号
为什么称SignalProducer为冷信号，看下面例子：

let producer = SignalProducer<String, NoError>.init { (observer, _) in
    print("新的订阅，启动操作")
    observer.send(value: "Hello")
    observer.send(value: "World")
}

let subscriber1 = Observer<String, NoError>(value: { print("观察者1接收到值 \($0)") })
let subscriber2 = Observer<String, NoError>(value: { print("观察者2接收到值 \($0)") })

print("观察者1订阅信号发生器")
producer.start(subscriber1)

print("观察者2订阅信号发生器")
producer.start(subscriber2)
//注意：发生器将再次启动工作

打印结果：
观察者1订阅信号发生器 新的订阅，启动操作 观察者1接收到值 Hello 观察者1接收到值 World 观察者2订阅信号发生器 新的订阅，启动操作 观察者2接收到值 Hello 观察者2接收到值 World
所以称SignalProducer是冷信号，任何一个订阅者/观察者都不会错过任何事件。start方法有关联一个观察者并激活信号的功能。

SignalProducer.empty

let emptyProducer = SignalProducer<String, NoError>.empty
let observer = Observer<String, NoError>.init(value:{ _ in print("打印值") },
                                      failed: { _ in print("失败调用") },
                                      completed:  { _ in print("完成调用") },
                                      interrupted:{ _ in print("阻断调用") })

emptyProducer.start(observer)

打印结果：
完成调用
注意：这里打印的是“完成调用”， 而Signal调用的是interrupted。可能是为了区分Signal是有时序的，SignalProducer是没有时序的。

SignalProducer.never

会返回一个什么都不会发送信号的生成器，同上。

buffer

创建一个时间队列可以回放已经发送的事件 在5.0已移除API

startWithXXX

如startWithSignal， 返回信号开始发送的事件

print("-------------------startWithSignal-------------------")
var v1: String?

SignalProducer<String, NoError>.init(value: "Hello")
    .on(value: { (text) in
        v1 = text
    })
    .startWithSignal { (signal, disposable) in
        print(signal)
        print(v1)   //nil
    }
print(v1)


print("-------------------startWithValues-------------------")
SignalProducer<String, NoError>.init(value: "Hello")
    .startWithValues { (value) in
        print(value)
    }

打印结果：
-------------------startWithSignal------------------- ReactiveSwift.Signal<Swift.String, Result.NoError> nil Optional("Hello") -------------------startWithValues------------------- Hello
总结起来：startWithCompleted、startWithFailed、startWithInterrupted同startWithValues，只不过只能接受相应的事件

lift

var word = ""
let transform: (Signal<String, NoError>) -> Signal<String, NoError> = { signal in
    word = "Hello"
    return signal
}

SignalProducer<String, NoError>.init(value: "").lift(transform).startWithValues { (_) in
    print(word)
}

会打印：Hello

这个个人觉得较难理解，“提起”对信号发生器进行操作，可理解为所有的原函数都是通过lift去实现的，接用中间信号来实现一系列的信号变换。

map

匹配值转换为新的值

mapError

把收到的error转换为新的Error

filter

过滤不符合条件的值

take

去前几次的值

以上都和热信号相关API使用类似。

observeOn

最后在介绍一个observeOn, 即在指定的调度器上分发事件

let baseProducer = SignalProducer<String, NoError>.init(values: ["Hello", "Nice", "to", "meet", "you"])
let completion = {
    print("是主线程吗？\(Thread.current.isMainThread)")
}
//主线程
baseProducer.observe(on: QueueScheduler(qos: DispatchQoS.default, name: "test")).startWithCompleted(completion)

//非主线程
baseProducer.startWithCompleted(completion)

打印结果：
是主线程吗？true 是主线程吗？false

---

相关链接：
Swift 响应式编程FRP使用RAC学习笔记1
Swift 响应式编程FRP使用RAC学习笔记2