美文网首页无法删除的专题iOS DeveloperiOS技术点
Hello ReactiveSwift(3): 基本操作 ——(

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

作者: Jorn丶Wu | 来源:发表于2017-05-09 22:08 被阅读204次

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

    目录：

    1. 使用event streams执行side effects
    • 观察
    • 注入effects
    1. 操作者结构
    • 提升
    1. 转换event streams
    • 映射
    • 过滤
    • 聚合
    1. 组合event streams
    • 组合最新值
    • 压缩
    1. 铺展event streams
    • 合并
    • 连接
    • 切换到最新
    1. 处理错误
    • 捕获错误
    • 可失败的转化
    • 重试
    • 映射错误
    • 促进

    一、使用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<String, NoError>.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<Int, NoError>.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<Int, NoError>.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<Int, NoError>.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<Int, NoError>.pipe()
let (lettersSignal, lettersObserver) = Signal<String, NoError>.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<Int, NoError>.pipe()
let (lettersSignal, lettersObserver) = Signal<String, NoError>.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<String, NoError>.pipe()
let (numbersSignal, numbersObserver) = Signal<String, NoError>.pipe()
let (signal, observer) = Signal<Signal<String, NoError>, 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<String, NoError>.pipe()
let (numbersSignal, numbersObserver) = Signal<String, NoError>.pipe()
let (signal, observer) = Signal<Signal<String, NoError>, 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<String, NoError>.pipe()
let (numbersSignal, numbersObserver) = Signal<String, NoError>.pipe()
let (signal, observer) = Signal<Signal<String, NoError>, 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<String, NSError>.pipe()
let producer = SignalProducer(signal: signal)

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

producer
    .flatMapError { _ in SignalProducer<String, NoError>(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<String, NSError> { (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<String, NSError>.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<Int, NoError>.pipe()
let (lettersSignal, lettersObserver) = Signal<String, NSError>.pipe()

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

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

    相关文章

      网友评论

        本文标题：Hello ReactiveSwift(3): 基本操作 ——(

        本文链接：https://www.haomeiwen.com/subject/nvbitxtx.html

        延伸阅读

        深度阅读

        • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

        栏目导航

        热点阅读

        无法删除的专题

        iOS Developer

        iOS技术点

        关于我们|服务条款|联系我们|Hello ReactiveSwift(3): 基本操作 ——(|投稿指南|网站地图|RSS订阅|排版工具|手机版

        提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

        Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

        备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

        本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

        所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！