ReactiveCocoa-Swift部分入门指南-Signal

转载自：valiantcat

学习过ReactiCocoa(以下简称RAC)的同学一般都会使用Objective-C的部分，不过RAC3之后支持了Swift，目前RAC3.x支持的是Swift1.x系列，RAC4支持的是Swift2.x系列。今天花了一点时间学习了下Swift部分示例代码。这里做些记录。Swift是支持playground，可以使用Markdown编写文档，并且所见即所得的界面方便学习。更可以插入图片。方便阅读。

• 学习知识必备
• Start
• PlaygroundUtility
• Signal
  • Subscription
  • empty
  • Never
• Operators
  • uniqueValues 唯一值
  • map
  • mapError
  • filter
  • ignoreNil
  • take
  • collect

学习知识必备

默认你已经学过RAC-OC部分， Swift语言，并对Monad，functional Programming有些简单的了解，或者，如果你学习了RXSwift更好。

Start

1.    git clone  [e-mail]:ReactiveCocoa/ReactiveCocoa.git    •    执行script/bootstrap 脚本    •    如果你安装了 [Cartheage](https://github.com/Carthage/Carthage) 使用  carthage checkout2.    打开 ReactiveCocoa.xcworkspace3.    编译 Result-Mac scheme4.    编译 ReactiveCocoa-Mac scheme5.    在workSpace目录中打开ReactiveCocoa.playground6.    Choose View > Show Debug Area、

PlaygroundUtility

先来观察一下这个里面有两个方法

1
2
3
4
5
6
7
8

public func scopedExample(exampleDescription: String, _ action: () -> Void) {
print("\n--- \(exampleDescription) ---\n")
action()
}

public enum Error: ErrorType {
case Example(String)
}

scopedExample 方便测试，并分割日志输出，Error也是为了测试方便。

Signal

一个Signal类型的实例，代表了一个有时序的并且可以被观察 (类似订阅)的事件流

信号通常被用来表示正在进行中的事件流，比如通知，用户输入等。用户(或者只要能造成事件的东西)产生的事件发送或者被接受，事件就被传递到信号上，并且被推送(push -Driven)到任何观察者哪里，并且所有观察者都是同时收到这些事件。

如果你想访问一系列的事件，就必须观察一个信号，观察一个信号并不会触发任何附作用，可以这样理解。信号是由生产者生产和推动(push)的，消费者(观察者)是不会对事件的生命周期有任何影响。在观察一个信号时，发送了什么事件，只能对这个事件做操作，因为信号是有时序的，不能随机的访问其他事件。

信号可以通过原函数去操作，比如 filter，map，reduce，也可以同时操作多个信号如zip，这些原函数只在 nextEvents生效(也就是对 comlete，failure等不生效)。
在一个信号的生命周期里，可以发送无数次的NextEvents事件，直到他们被终结，类似compleye，Faied，InterRuppet。终止事件没有数据值，所以他们必须被单独处理。

SUBSCRIPTION

一个信号通常被用来表示正在进行中的事件流,有时候他们被叫做热信号，这意味这订阅者可以错过一些在它订阅前发送的事件。订阅一个信号不会触发任何附作用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

        scopedExample("Subscription") {
            // Signal.pipe is a way to manually control a signal. the returned observer can be used to send values to the signal
            let (signal, observer) = Signal<Int, NonError>.pipe()

            let subscriber1 = Observer<Int, NonError>(next: { print("Subscriber 1 received \($0)") })
            let subscriber2 = Observer<Int, NonError>(next: { print("Subscriber 2 received \($0)") })

            print("Subscriber 1 subscribes to the signal")
            print("\(observer)")
            signal.observe(subscriber1)

            print("Send value `10` on the signal")
            // subscriber1 will receive the value
            observer.sendNext(10)

            print("Subscriber 2 subscribes to the signal")
            // Notice how nothing happens at this moment, i.e. subscriber2 does not receive the previously sent value
            signal.observe(subscriber2)

            print("Send value `20` on the signal")
            // Notice that now, subscriber1 and subscriber2 will receive the value
            observer.sendNext(20)
        }
        
        
--- Subscription ---

Subscriber 1 subscribes to the signal
Observer<Int, NonError>(action: (Function))
Send value `10` on the signal
Subscriber 1 received 10
Subscriber 2 subscribes to the signal
Send value `20` on the signal
Subscriber 1 received 20
Subscriber 2 received 20

因为Swift有泛型的存在，这样的话我们可以把Signal当作任何数据类型的容器，而不是像OC中利用上帝类型(id)。更加方便传递数据。

首先我们通过Siganl.pipe()创建了一个信号和一个观察者。
奇怪的是，在RACOC部分中，我们很少主动创建观察者，我们通常直接订阅信号就可以。
在Siwft中，通过pipe创建的信号是个热信号，类似与OC中的RACSubject系列，在RACSubject继承自RACSiganl又继承自RACStream，RACStream是一个Monad,它可以代表数据和数据的一系列的操作如map,flattenMap,bind
RACSubject又遵守了RACSubscriber协议，这个协议定义了可以发送数据的操作。
所以RACSubject即是一个信号，又是一个观察者。

在Swift部分的实现中，Signal并没有实现发送数据的方法。所以它需要一个内部的Observer去发送数据。所以它被pipe直接返回，

在外部我们需要自己实例化一个Observer观察者。去观察(订阅)事件，

可能在你查看pipe的实现的时候并不太好理解。把尾随闭包补全相对好理解点。

做个总结

1. RACOC中：

   RACSubject = RACSignal + RACSubscriper
   在订阅的时候，订阅者被放在了RACSubject内部存放，我们只需要去关注订阅的block实现即可。

2. RACSwift中:

   Signal：Just is a Signal
   所以需要一个内部观者者去充当发送数据的工具。外部的订阅需要自己手动实例观察者

3. 热信号：

   由于pipe方法返回的是热信号，所以一个订阅者会错过在订阅之前发送的事件。

EMPTY

空信号直接发送一个interrupted事件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

        scopedExample("`empty`") {
            let emptySignal = Signal<Int, NonError>.empty
            
            let observer = Observer<Int, NonError>(
                failed: { _ in print("error not called") },
                completed: { print("completed not called") },
                interrupted: { print("interrupted called") },
                next: { _ in print("next not called") }
            )
            
            emptySignal.observe(observer)
        }
        
        
        
--- `empty` ---

interrupted called

NEVER

一个never信号不会发送任何事件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

scopedExample("`never`") {
    let neverSignal = Signal<Int, NoError>.never
    
    let observer = Observer<Int, NoError>(
        failed: { _ in print("error not called") },
        completed: { print("completed not called") },
        interrupted: { print("interrupted not called") },
        next: { _ in print("next not called") }
    )
    
    neverSignal.observe(observer)
}


--- `never` ---

Operators

UNIQUEVALUES 唯一值

仅从集合中发送一次相同事件—类似与arrryQueue变成了SetQueue

注意：这会造成被发送的值被保留下来，用于以后发送的时候来检查是否重复，你可以编写一个函数来过滤重复值，这样可以减少内存消耗。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

scopedExample("`uniqueValues`") {
    let (signal, observer) = Signal<Int, NoError>.pipe()
    let subscriber = Observer<Int, NoError>(next: { print("Subscriber received \($0)") } )
    let uniqueSignal = signal.uniqueValues()

    uniqueSignal.observe(subscriber)
    observer.sendNext(1)
    observer.sendNext(2)
    observer.sendNext(3)
    observer.sendNext(4)
    observer.sendNext(3)
    observer.sendNext(3)
    observer.sendNext(5)
}

--- `uniqueValues` ---

Subscriber received 1
Subscriber received 2
Subscriber received 3
Subscriber received 4
Subscriber received 5

MAP

把每一个发送的值转换成新的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14

scopedExample("`map`") {
    let (signal, observer) = Signal<Int, NoError>.pipe()
    let subscriber = Observer<Int, NoError>(next: { print("Subscriber received \($0)") } )
    let mappedSignal = signal.map { $0 * 2 }

    mappedSignal.observe(subscriber)
    print("Send value `10` on the signal")
    observer.sendNext(10)
}

--- `map` ---

Send value `10` on the signal
Subscriber received 20

ITDogFire-throne