Hello ReactiveSwift(3): 基本操作 —

官方文档：
http://reactivecocoa.io/reactiveswift/docs/latest/index.html
实战项目：
https://github.com/JornWu/ZhiBo_Swift.git

目录：

使用event streams执行side effects

观察
注入effects

操作者结构

提升

转换event streams

映射
过滤
聚合

组合event streams

组合最新值
压缩

铺展event streams

合并
连接
切换到最新

处理错误

捕获错误
可失败的转化
重试
映射错误
促进

一、使用event streams注入side effects

1、观察

Signal可以被observe函数观察

signal.observe { event in
    switch event {
    case let .value(value):
        print("Value: \(value)")
    case let .failed(error):
        print("Failed: \(error)")
    case .completed:
        print("Completed")
    case .interrupted:
        print("Interrupted")
    }
}

同样，value, failed, completed 和interrupted的回调可以被提供和调用当响应的事件触发。

signal.observeValues { value in
    print("Value: \(value)")
}

signal.observeFailed { error in
    print("Failed: \(error)")
}

signal.observeCompleted {
    print("Completed")
}

signal.observeInterrupted {
    print("Interrupted")
}

2、注入effects

Side effects可以通过on操作被注入到某个event stream中。且实际上并没有订阅它。

let producer = signalProducer
    .on(starting: { 
        print("Starting")
    }, started: { 
        print("Started")
    }, event: { event in
        print("Event: \(event)")
    }, value: { value in
        print("Value: \(value)")
    }, failed: { error in
        print("Failed: \(error)")
    }, completed: { 
        print("Completed")
    }, interrupted: { 
        print("Interrupted")
    }, terminated: { 
        print("Terminated")
    }, disposed: { 
        print("Disposed")
    })

请注意，没有必要提供所有参数 - 它们都是可选的，您只需要为您关心的事件提供回调。
请注意，直到producer开始（可能在其他地方）才会打印任何内容。

二、操作者结构

1、提升

Signal操作可根据SignalProducer使用Lift方法被提升，这样将会为每个Signal创建一个新的SignalProducer，通过应用所给的操作。就像操作已被应用于每个单独的生成Signal一样。

三、转换event streams

这些操作将每个event stream 转换为新的stream。

1、映射

map操作用于转换某个event stream中的值，创建一个新的带有结果的stream。

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

signal
    .map { string in string.uppercased() }
    .observeValues { value in print(value) }

observer.send(value: "a")     // Prints A
observer.send(value: "b")     // Prints B
observer.send(value: "c")     // Prints C

2、过滤

filter用于仅包含值且满足该谓词的event stream。

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

signal
    .filter { number in number % 2 == 0 }
    .observeValues { value in print(value) }

observer.send(value: 1)     // Not printed
observer.send(value: 2)     // Prints 2
observer.send(value: 3)     // Not printed
observer.send(value: 4)     // prints 4

3、聚合

reduce操作用于聚合某个event stream的所有值到一个单一的联合值，请注意，最终值仅在输入流完成后发送。

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

signal
    .reduce(1) { $0 * $1 }
    .observeValues { value in print(value) }

observer.send(value: 1)     // nothing printed
observer.send(value: 2)     // nothing printed
observer.send(value: 3)     // nothing printed
observer.sendCompleted()    // prints 6

collect操作用于聚合某个event stream的所有值到一个单一的数组，请注意，最终值仅在输入流完成后发送。

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

signal
    .collect()
    .observeValues { value in print(value) }

observer.send(value: 1)     // nothing printed
observer.send(value: 2)     // nothing printed
observer.send(value: 3)     // nothing printed
observer.sendCompleted()   // prints [1, 2, 3]

四、组合event streams

这些运算符将来自多个事件流的值组合成一个新的统一流。

1、组合最新值

该combineLatest函数组合了两个（或多个）事件流的最新值。
所得到的stream将在每个输入发送至少一个值后才发送其第一个值。之后，任何新的输入值将引起一个新的输出值。

let (numbersSignal, numbersObserver) = Signal.pipe()
let (lettersSignal, lettersObserver) = Signal.pipe()

let signal = Signal.combineLatest(numbersSignal, lettersSignal)
signal.observeValues { next in print("Next: \(next)") }
signal.observeCompleted { print("Completed") }

numbersObserver.send(value: 0)      // nothing printed
numbersObserver.send(value: 1)      // nothing printed
lettersObserver.send(value: "A")    // prints (1, A)
numbersObserver.send(value: 2)      // prints (2, A)
numbersObserver.sendCompleted()  // nothing printed
lettersObserver.send(value: "B")    // prints (2, B)
lettersObserver.send(value: "C")    // prints (2, C)
lettersObserver.sendCompleted()  // prints "Completed"

该combineLatest(with:)操作的方式相同，但作为另一种操作。

2、压缩

该zip函数将两个（或多个）事件流的值成对连接。任何第N个元组的元素对应于输入流的第N个元素。
这意味着输出流的第N个值不能发送，直到每个输入至少发送了N个值。

let (numbersSignal, numbersObserver) = Signal.pipe()
let (lettersSignal, lettersObserver) = Signal.pipe()

let signal = Signal.zip(numbersSignal, lettersSignal)
signal.observeValues { next in print("Next: \(next)") }
signal.observeCompleted { print("Completed") }

numbersObserver.send(value: 0)      // nothing printed
numbersObserver.send(value: 1)      // nothing printed
lettersObserver.send(value: "A")    // prints (0, A)
numbersObserver.send(value: 2)      // nothing printed
numbersObserver.sendCompleted()  // nothing printed
lettersObserver.send(value: "B")    // prints (1, B)
lettersObserver.send(value: "C")    // prints (2, C) & "Completed"

该zipWith操作的方式相同，但作为另一种操作。

五、铺展event streams

1、合并

该.merge策略是立即将内部事件流的每个值转发到外部事件流。在外部事件流或任何内部事件流上发送的任何失败都将立即发送到铺展的事件流中并终止。

let (lettersSignal, lettersObserver) = Signal.pipe()
let (numbersSignal, numbersObserver) = Signal.pipe()
let (signal, observer) = Signal, NoError>.pipe()

signal.flatten(.merge).observeValues { print($0) }

observer.send(value: lettersSignal)
observer.send(value: numbersSignal)
observer.sendCompleted()

lettersObserver.send(value: "a")    // prints "a"
numbersObserver.send(value: "1")    // prints "1"
lettersObserver.send(value: "b")    // prints "b"
numbersObserver.send(value: "2")    // prints "2"
lettersObserver.send(value: "c")    // prints "c"
numbersObserver.send(value: "3")    // prints "3"

2、连接

该.concat策略用于序列化内部事件流的事件。观察外部事件流。直到前一个完成之后才会观察到每个后续的事件流。失败会立即转发到铺展事件流。

let (lettersSignal, lettersObserver) = Signal.pipe()
let (numbersSignal, numbersObserver) = Signal.pipe()
let (signal, observer) = Signal, NoError>.pipe()

signal.flatten(.concat).observeValues { print($0) }

observer.send(value: lettersSignal)
observer.send(value: numbersSignal)
observer.sendCompleted()

numbersObserver.send(value: "1")    // nothing printed
lettersObserver.send(value: "a")    // prints "a"
lettersObserver.send(value: "b")    // prints "b"
numbersObserver.send(value: "2")    // nothing printed
lettersObserver.send(value: "c")    // prints "c"
lettersObserver.sendCompleted()     // nothing printed
numbersObserver.send(value: "3")    // prints "3"
numbersObserver.sendCompleted()     // nothing printed

3、切换到最新值

该.latest策略仅转发最新输入事件流中的值或失败。

let (lettersSignal, lettersObserver) = Signal.pipe()
let (numbersSignal, numbersObserver) = Signal.pipe()
let (signal, observer) = Signal, NoError>.pipe()

signal.flatten(.latest).observeValues { print($0) }

observer.send(value: lettersSignal) // nothing printed
numbersObserver.send(value: "1")    // nothing printed
lettersObserver.send(value: "a")    // prints "a"
lettersObserver.send(value: "b")    // prints "b"
numbersObserver.send(value: "2")    // nothing printed
observer.send(value: numbersSignal) // nothing printed
lettersObserver.send(value: "c")    // nothing printed
numbersObserver.send(value: "3")    // prints "3"

六、处理错误

这些运算符用于处理事件流可能产生的失败，或执行可能会在事件流中失败的操作。

1、捕获错误

该flatMapError操作捕捉输入事件流中可能出现的任何失败，然后在其位置开始一个新的SignalProducer。

let (signal, observer) = Signal.pipe()
let producer = SignalProducer(signal: signal)

let error = NSError(domain: "domain", code: 0, userInfo: nil)

producer
    .flatMapError { _ in SignalProducer(value: "Default") }
    .startWithValues { print($0) }


observer.send(value: "First")     // prints "First"
observer.send(value: "Second")    // prints "Second"
observer.send(error: error)       // prints "Default"

2、可失败的转化

SignalProducer.attempt(_:)允许您将可用操作转换为事件流。在attempt(_:)与attemptMap(_:)操作允许您在一个事件流进行failable操作或变换。

let dictionaryPath = URL(fileURLWithPath: "/usr/share/dict/words")

// Create a `SignalProducer` that lazily attempts the closure
// whenever it is started
let data = SignalProducer.attempt { try Data(contentsOf: dictionaryPath) }

// Lazily apply a failable transformation
let json = data.attemptMap { try JSONSerialization.jsonObject(with: $0) }

json.startWithResult { result in
    switch result {
    case let .success(words):
        print("Dictionary as JSON:")
        print(words)
    case let .failure(error):
        print("Couldn't parse dictionary as JSON: \(error)")
    }

3、重试

该retry操作将重新启动原来的SignalProducer在失败后count次。

var tries = 0
let limit = 2
let error = NSError(domain: "domain", code: 0, userInfo: nil)
let producer = SignalProducer { (observer, _) in
    tries += 1
    if tries <= limit {
        observer.send(error: error)
    } else {
        observer.send(value: "Success")
        observer.sendCompleted()
    }
}

producer
    .on(failed: {e in print("Failure")})    // prints "Failure" twice
    .retry(upTo: 2)
    .start { event in
        switch event {
        case let .value(next):
            print(next)                     // prints "Success"
        case let .failed(error):
            print("Failed: \(error)")
        case .completed:
            print("Completed")
        case .interrupted:
            print("Interrupted")
        }
}

如果SignalProducer尝试count后仍不成功，结果SignalProducer将会失败。例如，在本例中如果使用retry(1)代替上述retry(2)，"Success"的打印将被"Failed: Error Domain=domain Code=0 "(null)"代替。

4、映射错误

在mapError操作将转化的event stream中的任何失败的错误成一个新的错误。

enum CustomError: String, Error {
    case foo = "Foo Error"
    case bar = "Bar Error"
    case other = "Other Error"
}

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

signal
    .mapError { (error: NSError) -> CustomError in
        switch error.domain {
        case "com.example.foo":
            return .foo
        case "com.example.bar":
            return .bar
        default:
            return .other
        }
    }
    .observeFailed { error in
        print(error.rawValue)
}

observer.send(error: NSError(domain: "com.example.foo", code: 42, userInfo: nil))    // prints "Foo Error"

5、促进

该promoteErrors操作促进某个不会产生失败的event stream成为一个能产生失败的event stream。

let (numbersSignal, numbersObserver) = Signal.pipe()
let (lettersSignal, lettersObserver) = Signal.pipe()

numbersSignal
    .promoteErrors(NSError.self)
    .combineLatest(with: lettersSignal)

做得到的流仍然实际上也不会产生失败
，但这是有用的，因为一些运算符 combine streams 需要输入具有匹配的错误类型。

Hello ReactiveSwift(3): 基本操作 ——(简译)