RxSwift 入坑手册 Part0 - 基础概念

最新推荐文章于 2022-11-21 07:58:08 发布
最新推荐文章于 2022-11-21 07:58:08 发布
阅读量633 收藏
点赞数

原文转载自：点击打开链接

（前面的坑还没填完，我又来开坑了。。。Part 0 走起！）

RxSwift 是我在 Github 上关注已久的一个项目，今天花点时间过了一下它的示例代码，感觉很有意思。

我主要是通过项目里的 Rx.playground 进行学习和了解的，这种方式确实便捷高效。只需要把文档用 /*: */ 注释即可，直接用 Markdown 编写，简单方便。不过 Xcode7 中这种方式现在还不是很稳定，会有大量的空行，而且有个最大的问题就是阅读到中间然后切到其他文件再切回来的时候，阅读的进度条是从头开始的，并不能记录上次阅读的位置。心累。

下面是我的简单笔记，只是把学习过程中的收获记录下来，大部分内容来自于项目内的 playground 。注意！是很大部分！而且操场里图文并茂，很容易理解。所以，各位如果感兴趣，建议 clone 官方项目，跑个操场玩玩。

参考文献中罗列了我在学习过程中查阅的相关资料，可以作为补充阅读。

SupportCode

在进入正题之前，先看下项目里的 SupportCode.swift ，主要为 playground 提供了两个便利函数。

一个是 example 函数，专门用来写示例代码的，统一输出 log 便于标记浏览，同时还能保持变量不污染全局：

public func example(description: String, action: () -> ()) {
    print("\n--- \(description) example ---")
    action()
}

另一个是 delay 函数，通过 dispatch_after 用来演示延时的：

public func delay(delay:Double, closure:()->()) {
    dispatch_after(
        dispatch_time(
            DISPATCH_TIME_NOW,
            Int64(delay * Double(NSEC_PER_SEC))
        ),
        dispatch_get_main_queue(), closure)
}

Introduction

主要介绍了 Rx 的基础： Observable 。 Observable<Element> 是观察者模式中被观察的对象，相当于一个事件序列 (GeneratorType) ，会向订阅者发送新产生的事件信息。事件信息分为三种： 

  • .Next(value) 表示新的事件数据。
  • .Completed 表示事件序列的完结。
  • .Error 同样表示完结，但是代表异常导致的完结。

（打个岔：协议命名，想起来上午汤哥在微博说的一段话：

另外，我觉得 protocol 名字用形容词会更加语义分明，比如 Swift : Flyable, Killable, Visible。全用名词的话显得比较生硬，比如 Swift : Head, Wings, Ass。

empty

empty 是一个空的序列，它只发送 .Completed 消息。

example("empty") {
    let emptySequence: Observable<Int> = empty()

    let subscription = emptySequence
        .subscribe { event in
            print(event)
        }
}

--- empty example ---
Completed

never

never 是没有任何元素、也不会发送任何事件的空序列。

example("never") {
    let neverSequence: Observable<String> = never()

    let subscription = neverSequence
        .subscribe { _ in
            print("This block is never called.")
        }
}

--- never example ---

just

just 是只包含一个元素的序列，它会先发送 .Next(value) ，然后发送 .Completed 。

example("just") {
    let singleElementSequence = just(32)

    let subscription = singleElementSequence
        .subscribe { event in
            print(event)
        }
}

--- just example ---
Next(32)
Completed

sequenceOf

sequenceOf 可以把一系列元素转换成事件序列。

example("sequenceOf") {
    let sequenceOfElements/* : Observable<Int> */ = sequenceOf(0, 1, 2, 3)

    let subscription = sequenceOfElements
        .subscribe { event in
            print(event)
        }
}

--- sequenceOf example ---
Next(0)
Next(1)
Next(2)
Next(3)
Completed

form

form 是通过 asObservable() 方法把 Swift 中的序列 (SequenceType) 转换成事件序列。 

example("from") {
    let sequenceFromArray = [1, 2, 3, 4, 5].asObservable()

    let subscription = sequenceFromArray
        .subscribe { event in
            print(event)
        }
}

--- from example ---
Next(1)
Next(2)
Next(3)
Next(4)
Next(5)
Completed

create

create 可以通过闭包创建序列，通过 .on(e: Event) 添加事件。

example("create") {
    let myJust = { (singleElement: Int) -> Observable<Int> in
        return create { observer in
            observer.on(.Next(singleElement))
            observer.on(.Completed)

            return NopDisposable.instance
        }
    }

    let subscription = myJust(5)
        .subscribe { event in
            print(event)
        }
}

--- create example ---
Next(5)
Completed

failWith

failWith 创建一个没有元素的序列，只会发送失败 (.Error) 事件。

example("failWith") {
    let error = NSError(domain: "Test", code: -1, userInfo: nil)

    let erroredSequence: Observable<Int> = failWith(error)

    let subscription = erroredSequence
        .subscribe { event in
            print(event)
        }
}

--- failWith example ---
Error(Error Domain=Test Code=-1 "The operation couldn’t be completed. (Test error -1.)")

deferred

deferred 会等到有订阅者的时候再通过工厂方法创建 Observable 对象，每个订阅者订阅的对象都是内容相同而完全独立的序列。

example("deferred") {
    let deferredSequence: Observable<Int> = deferred {
        print("creating")
        return create { observer in
            print("emmiting")
            observer.on(.Next(0))
            observer.on(.Next(1))
            observer.on(.Next(2))

            return NopDisposable.instance
        }
    }

    print("go")

    deferredSequence
        .subscribe { event in
            print(event)
    }

    deferredSequence
        .subscribe { event in
            print(event)
        }
}

--- deferred example ---
go
creating
emmiting
Next(0)
Next(1)
Next(2)
creating
emmiting
Next(0)
Next(1)
Next(2)

为什么需要 defferd 这样一个奇怪的家伙呢？其实这相当于是一种延时加载，因为在添加监听的时候数据未必加载完毕，例如下面这个例子：

example("TestDeferred") {
    var value: String? = nil
    var subscription: Observable<String?> = just(value)

    // got value
    value = "Hello!"

    subscription.subscribe { event in
        print(event)
    }
}

--- TestDeferred example ---
Next(nil)
Completed

如果使用 deffered 则可以正常显示想要的数据：

example("TestDeferred") {
    var value: String? = nil
    var subscription: Observable<String?> = deferred {
        return just(value)
    }

    // got value
    value = "Hello!"

    subscription.subscribe { event in
        print(event)
    }

}

--- TestDeferred example ---
Next(Optional("Hello!"))
Completed

Subjects

接下来是关于 Subject 的内容。 Subject 可以看做是一种代理和桥梁。它既是订阅者又是订阅源，这意味着它既可以订阅其他 Observable 对象，同时又可以对它的订阅者们发送事件。

如果把 Observable 理解成不断输出事件的水管，那 Subject 就是套在上面的水龙头。它既怼着一根不断出水的水管，同时也向外面输送着新鲜水源。如果你直接用水杯接着水管的水，那可能导出来什么王水胶水完全把持不住；如果你在水龙头下面接着水，那你可以随心所欲的调成你想要的水速和水温。

（好吧上面一段文档里没有，是我瞎掰的，如果理解错了还望打脸(￣ε(#￣)☆╰╮(￣▽￣///))

在开始下面的代码之前，先定义一个辅助函数用于输出数据： 

func writeSequenceToConsole<O: ObservableType>(name: String, sequence: O) {
    sequence
        .subscribe { e in
            print("Subscription: \(name), event: \(e)")
        }
}

PublishSubject

PublishSubject 会发送订阅者从订阅之后的事件序列。

example("PublishSubject") {
    let subject = PublishSubject<String>()
    writeSequenceToConsole("1", sequence: subject)
    subject.on(.Next("a"))
    subject.on(.Next("b"))
    writeSequenceToConsole("2", sequence: subject)
    subject.on(.Next("c"))
    subject.on(.Next("d"))
}


--- PublishSubject example ---
Subscription: 1, event: Next(a)
Subscription: 1, event: Next(b)
Subscription: 1, event: Next(c)
Subscription: 2, event: Next(c)
Subscription: 1, event: Next(d)
Subscription: 2, event: Next(d)

ReplaySubject

ReplaySubject 在新的订阅对象订阅的时候会补发所有已经发送过的数据队列， bufferSize 是缓冲区的大小，决定了补发队列的最大值。如果 bufferSize 是1，那么新的订阅者出现的时候就会补发上一个事件，如果是2，则补两个，以此类推。

example("ReplaySubject") {
    let subject = ReplaySubject<String>.create(bufferSize: 1)

    writeSequenceToConsole("1", sequence: subject)
    subject.on(.Next("a"))
    subject.on(.Next("b"))
    writeSequenceToConsole("2", sequence: subject)
    subject.on(.Next("c"))
    subject.on(.Next("d"))
}

--- ReplaySubject example ---
Subscription: 1, event: Next(a)
Subscription: 1, event: Next(b)
Subscription: 2, event: Next(b) // 补了一个 b
Subscription: 1, event: Next(c)
Subscription: 2, event: Next(c)
Subscription: 1, event: Next(d)
Subscription: 2, event: Next(d)

BehaviorSubject

BehaviorSubject 在新的订阅对象订阅的时候会发送最近发送的事件，如果没有则发送一个默认值。

example("BehaviorSubject") {
    let subject = BehaviorSubject(value: "z")
    writeSequenceToConsole("1", sequence: subject)
    subject.on(.Next("a"))
    subject.on(.Next("b"))
    writeSequenceToConsole("2", sequence: subject)
    subject.on(.Next("c"))
    subject.on(.Completed)
}

--- BehaviorSubject example ---
Subscription: 1, event: Next(z)
Subscription: 1, event: Next(a)
Subscription: 1, event: Next(b)
Subscription: 2, event: Next(b)
Subscription: 1, event: Next(c)
Subscription: 2, event: Next(c)
Subscription: 1, event: Completed
Subscription: 2, event: Completed

Variable

Variable 是基于 BehaviorSubject 的一层封装，它的优势是：不会被显式终结。即：不会收到 .Completed和 .Error 这类的终结事件，它会主动在析构的时候发送 .Complete 。

example("Variable") {
    let variable = Variable("z")
    writeSequenceToConsole("1", sequence: variable)
    variable.value = "a"
    variable.value = "b
    writeSequenceToConsole("2", sequence: variable)
    variable.value = "c"
}

--- Variable example ---
Subscription: 1, event: Next(z)
Subscription: 1, event: Next(a)
Subscription: 1, event: Next(b)
Subscription: 2, event: Next(b)
Subscription: 1, event: Next(c)
Subscription: 2, event: Next(c)
Subscription: 1, event: Completed
Subscription: 2, event: Completed

Transform

我们可以对序列做一些转换，类似于 Swift 中 CollectionType 的各种转换。在以前的坑中曾经提到过，可以参考：函数式的函数。

map

map 就是对每个元素都用函数做一次转换，挨个映射一遍。

example("map") {
    let originalSequence = sequenceOf(1,2,3)

    originalSequence
        .map { $0 * 2 }
        .subscribe { print($0) }
}

--- map example ---
Next(2)
Next(4)
Next(6)
Completed

flatMap

map 在做转换的时候很容易出现『升维』的情况，即：转变之后，从一个序列变成了一个序列的序列。

什么是『升维』？在集合中我们可以举这样一个例子，我有一个好友列表 [p1, p2, p3]，那么如果要获取我好友的好友的列表，可以这样做：

myFriends.map { $0.getFriends() }

结果就成了 [[p1-1, p1-2, p1-3], [p2-1], [p3-1, p3-2]] ，这就成了好友的好友列表的列表了。这就是一个『升维』的例子。

（以上内容文档中依旧没有，依旧是我瞎掰的，依旧欢迎有错误当面打脸(￣ε(#￣)☆╰╮(￣▽￣///))

在 Swift 中，我们可以用 flatMap 过滤掉 map 之后的 nil 结果。在 Rx 中， flatMap 可以把一个序列转换成一组序列，然后再把这一组序列『拍扁』成一个序列。

example("flatMap") {
    let sequenceInt = sequenceOf(1, 2, 3)
    let sequenceString = sequenceOf("A", "B", "--")

    sequenceInt
        .flatMap { int in
            sequenceString
        }
        .subscribe {
            print($0)
        }
}

--- flatMap example ---
Next(A)
Next(B)
Next(--)
Next(A)
Next(B)
Next(--)
Next(A)
Next(B)
Next(--)
Completed

scan

scan 有点像 reduce ，它会把每次的运算结果累积起来，作为下一次运算的输入值。

example("scan") {
    let sequenceToSum = sequenceOf(0, 1, 2, 3, 4, 5)

    sequenceToSum
        .scan(0) { acum, elem in
            acum + elem
        }
        .subscribe {
            print($0)
        }
}

--- scan example ---
Next(0)
Next(1)
Next(3)
Next(6)
Next(10)
Next(15)
Completed

Filtering

除了上面的各种转换，我们还可以对序列进行过滤。

filter

filter 只会让符合条件的元素通过。

example("filter") {
    let subscription = sequenceOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
        .filter {
            $0 % 2 == 0
        }
        .subscribe {
            print($0)
        }
}

--- filter example ---
Next(0)
Next(2)
Next(4)
Next(6)
Next(8)
Completed

distinctUntilChanged

distinctUntilChanged 会废弃掉重复的事件。

example("distinctUntilChanged") {
    let subscription = sequenceOf(1, 2, 3, 1, 1, 4)
        .distinctUntilChanged()
        .subscribe {
            print($0)
        }
}

--- distinctUntilChanged example ---
Next(1)
Next(2)
Next(3)
Next(1)
Next(4)
Completed

take

take 只获取序列中的前 n 个事件，在满足数量之后会自动 .Completed 。

example("take") {
    let subscription = sequenceOf(1, 2, 3, 4, 5, 6)
        .take(3)
        .subscribe {
            print($0)
        }
}

--- take example ---
Next(1)
Next(2)
Next(3)
Completed

Combining

这部分是关于序列的运算，可以将多个序列源进行组合拼装成一个新的事件序列。

startWith

startWith 会在队列开始之前插入一个事件元素。

example("startWith") {
    let subscription = sequenceOf(4, 5, 6)
        .startWith(3)
        .subscribe {
            print($0)
        }
}

--- startWith example ---
Next(3)
Next(4)
Next(5)
Next(6)
Completed

combineLatest

如果存在两条事件队列，需要同时监听，那么每当有新的事件发生的时候，combineLatest 会将每个队列的最新的一个元素进行合并。

example("combineLatest 1") {
    let intOb1 = PublishSubject<String>()
    let intOb2 = PublishSubject<Int>()

    combineLatest(intOb1, intOb2) {
        "\($0) \($1)"
        }
        .subscribe {
            print($0)
        }

    intOb1.on(.Next("A"))
    intOb2.on(.Next(1))
    intOb1.on(.Next("B"))
    intOb2.on(.Next(2))
}

--- combineLatest 1 example ---
Next(A 1)
Next(B 1)
Next(B 2)

zip

zip 人如其名，就是合并两条队列用的，不过它会等到两个队列的元素一一对应地凑齐了之后再合并，正如百折不撓的米斯特菜所提醒的， zip 就像是拉链一样，两根拉链拉着拉着合并到了一根上：

example("zip 1") {
    let intOb1 = PublishSubject<String>()
    let intOb2 = PublishSubject<Int>()
    zip(intOb1, intOb2) {
        "\($0) \($1)"
        }
        .subscribe {
            print($0)
        }
    intOb1.on(.Next("A"))
    intOb2.on(.Next(1))
    intOb1.on(.Next("B"))
    intOb1.on(.Next("C"))
    intOb2.on(.Next(2))
}

--- zip 1 example ---
Next(A 1)
Next(B 2)

marge

merge 就是 merge 啦，把两个队列按照顺序组合在一起。

example("merge 1") {
    let subject1 = PublishSubject<Int>()
    let subject2 = PublishSubject<Int>()

    sequenceOf(subject1, subject2)
        .merge()
        .subscribeNext { int in
            print(int)
        }

    subject1.on(.Next(1))
    subject1.on(.Next(2))
    subject2.on(.Next(3))
    subject1.on(.Next(4))
    subject2.on(.Next(5))
}

--- merge 1 example ---
1
2
3
4
5

switch

当你的事件序列是一个事件序列的序列 (Observable<Observable<T>>) 的时候，（可以理解成二维序列？），可以使用 switch 将序列的序列平铺成一维，并且在出现新的序列的时候，自动切换到最新的那个序列上。和 merge 相似的是，它也是起到了将多个序列『拍平』成一条序列的作用。

example("switchLatest") {
    let var1 = Variable(0)

    let var2 = Variable(200)

    // var3 is like an Observable<Observable<Int>>
    let var3 = Variable(var1)

    let d = var3
        .switchLatest()
        .subscribe {
            print($0)
        }

    var1.value = 1
    var1.value = 2
    var1.value = 3
    var1.value = 4

    var3.value = var2
    var2.value = 201
    var1.value = 5

    var3.value = var1
    var2.value = 202
    var1.value = 6
}

--- switchLatest example ---
Next(0)
Next(1)
Next(2)
Next(3)
Next(4)
Next(200)
Next(201)
Next(5)
Next(6)

注意，虽然都是『拍平』，但是和 flatmap 是不同的， flatmap 是将一条序列变成另一条序列，而这变换过程会让维度变高，所以需要『拍平』，而 switch 是将本来二维的序列（序列的序列）拍平成了一维的序列。

Error Handling

在事件序列中，遇到异常也是很正常的事情，有以下几种处理异常的手段。

catchError

catchError 可以捕获异常事件，并且在后面无缝接上另一段事件序列，丝毫没有异常的痕迹。

example("catchError 1") {
    let sequenceThatFails = PublishSubject<Int>()
    let recoverySequence = sequenceOf(100, 200)

    sequenceThatFails
        .catchError { error in
            return recoverySequence
        }
        .subscribe {
            print($0)
        }

    sequenceThatFails.on(.Next(1))
    sequenceThatFails.on(.Next(2))
    sequenceThatFails.on(.Error(NSError(domain: "Test", code: 0, userInfo: nil)))
}

--- catchError 1 example ---
Next(1)
Next(2)
Next(100)
Next(200)
Completed

retry

retry 顾名思义，就是在出现异常的时候会再去从头订阅事件序列，妄图通过『从头再来』解决异常。

example("retry") {
    var count = 1 // bad practice, only for example purposes
    let funnyLookingSequence: Observable<Int> = create { observer in
        let error = NSError(domain: "Test", code: 0, userInfo: nil)
        observer.on(.Next(0))
        observer.on(.Next(1))
        if count < 2 {
            observer.on(.Error(error))
            count++
        }
        observer.on(.Next(2))
        observer.on(.Completed)

        return NopDisposable.instance
    }

    funnyLookingSequence
        .retry()
        .subscribe {
            print($0)
        }
}

--- retry example ---
Next(0)
Next(1)
Next(0)
Next(1)
Next(2)
Completed

Utility

这里列举了针对事件序列的一些方法。

subscribe

subscribe 在前面已经接触过了，有新的事件就会触发。

example("subscribe") {
    let sequenceOfInts = PublishSubject<Int>()

    sequenceOfInts
        .subscribe {
            print($0)
        }

    sequenceOfInts.on(.Next(1))
    sequenceOfInts.on(.Completed)
}

--- subscribe example ---
Next(1)
Completed

subscribeNext

subscribeNext 也是订阅，但是只订阅 .Next 事件。

example("subscribeNext") {
    let sequenceOfInts = PublishSubject<Int>()

    sequenceOfInts
        .subscribeNext {
            print($0)
        }

    sequenceOfInts.on(.Next(1))
    sequenceOfInts.on(.Completed)
}

--- subscribeNext example ---
1

subscribeCompleted

subscribeCompleted 是只订阅 .Completed 完成事件。

example("subscribeCompleted") {
    let sequenceOfInts = PublishSubject<Int>()

    sequenceOfInts
        .subscribeCompleted {
            print("It's completed")
        }

    sequenceOfInts.on(.Next(1))
    sequenceOfInts.on(.Completed)
}

--- subscribeCompleted example ---
It's completed

subscribeError

subscribeError 只订阅 .Error 失败事件。

example("subscribeError") {
    let sequenceOfInts = PublishSubject<Int>()

    sequenceOfInts
        .subscribeError { error in
            print(error)
        }

    sequenceOfInts.on(.Next(1))
    sequenceOfInts.on(.Error(NSError(domain: "Examples", code: -1, userInfo: nil)))
}

--- subscribeError example ---
Error Domain=Examples Code=-1 "The operation couldn’t be completed. (Examples error -1.)"

doOn

doOn 可以监听事件，并且在事件发生之前调用。

example("doOn") {
    let sequenceOfInts = PublishSubject<Int>()

    sequenceOfInts
        .doOn {
            print("Intercepted event \($0)")
        }
        .subscribe {
            print($0)
        }

    sequenceOfInts.on(.Next(1))
    sequenceOfInts.on(.Completed)
}

--- doOn example ---
Intercepted event Next(1)
Next(1)
Intercepted event Completed
Completed

Conditional

我们可以对多个事件序列做一些复杂的逻辑判断。

takeUntil

takeUntil 其实就是 take ，它会在终于等到那个事件之后触发 .Completed 事件。

example("takeUntil") {
    let originalSequence = PublishSubject<Int>()
    let whenThisSendsNextWorldStops = PublishSubject<Int>()

    originalSequence
        .takeUntil(whenThisSendsNextWorldStops)
        .subscribe {
            print($0)
        }

    originalSequence.on(.Next(1))
    originalSequence.on(.Next(2))

    whenThisSendsNextWorldStops.on(.Next(1))

    originalSequence.on(.Next(3))
}

--- takeUntil example ---
Next(1)
Next(2)
Completed

takeWhile

takeWhile 则是可以通过状态语句判断是否继续 take 。

example("takeWhile") {
    let sequence = PublishSubject<Int>()
    sequence
        .takeWhile { int in
            int < 2
        }
        .subscribe {
            print($0)
        }
    sequence.on(.Next(1))
    sequence.on(.Next(2))
    sequence.on(.Next(3))
}

--- takeWhile example ---
Next(1)
Completed

Aggregate

我们可以对事件序列做一些集合运算。

concat

concat 可以把多个事件序列合并起来。 

example("concat") {
    let var1 = BehaviorSubject(value: 0)
    let var2 = BehaviorSubject(value: 200)

    // var3 is like an Observable<Observable<Int>>
    let var3 = BehaviorSubject(value: var1)

    let d = var3
        .concat()
        .subscribe {
            print($0)
        }

    var1.on(.Next(1))
    var1.on(.Next(2))

    var3.on(.Next(var2))

    var2.on(.Next(201))

    var1.on(.Next(3))
    var1.on(.Completed)

    var2.on(.Next(202))
}

--- concat example ---
Next(0)
Next(1)
Next(2)
Next(3)
Next(201)
Next(202)

reduce

这里的 reduce 和 CollectionType 中的 reduce 是一个意思，都是指通过对一系列数据的运算最后生成一个结果。

example("reduce") {
    sequenceOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
        .reduce(0, +)
        .subscribe {
            print($0)
        }
}

--- reduce example ---
Next(45)
Completed

Connectable

坑待填，Xcode 里这个操场跑不起来了。

Next

基础入门大概就是这些了，有了前面 《Functional Reactive Programming in Swift - Part 1》 的铺垫，似乎理解起来十分愉快，不过还是不够深入，在下一章会在具体项目中操练起来。

操练起来！跑个操场吧少年！

Run the playground in your Xcode!

参考文献：

#RxSwift
 使用 Yeoman + AngularJS + Gulp 搭建 Web 应用
 
RxSwift 入坑手册 Part1 - 示例实战 

Companion_1314
关注
RxSwift使用教程
Leo的专栏
07-08 4万+
前言RxSwift是Swift函数响应式编程的一个开源库，由Github的ReactiveX组织开发，维护。RxSwift的目的是让让数据/事件流和异步任务能够更方便的序列化处理，能够使用Swift进行响应式编程目前，RxSwift在Github上收到了5000+Star，600+fork。本文的目的 介绍RxSwift的核心思想 讲解RxSwift的基础使用 介绍RxSwift的优点 如果你有时间
初识RxSwift及使用教程
iOS开发by韩俊强
08-01 605
什么是RxSwift？RxSwift是Swift函数响应式编程的一个开源库，由Github的ReactiveX组织开发、维护其他语言像C#, Java 和 js 也有，Rx.NET、RxJava、RxJSRxSwift的目的是让让数据/事件流和异步任务能够更方便的序列化处理，能够使用swift进行响应式编程函数式响应编程?RxSwift做了什么?观察者模式什么KVO，通知, 甚至代理都是观察者模式
RxSwift使用教程大全 韩俊强的博客
weixin_34343308的博客
08-03 173
接上一篇:初识RxSwift及使用教程 韩俊强的博客 本文档内容来自于 RxSwift 的 Playground。记录大多数 ReactiveX 的概念和操作符。 (部分翻译和注解来自 ReactiveX文档中文翻译) Introduction 为什么使用 RxSwift? 我们写的很多代码实际上是为了解决和响应外部事件。当用户操作一个控件的时候...
RxSwift入门教程（一）
HaKimK
12-29 607
Getting Started(This project tries to be consistent with ReactiveX.io.The general cross platform documentation and tutorials should also be valid in case of Rxswift.) *Observables aka Sequences *Disp
RxSwift教程 （warnings）
HaKimK
12-26 355
Warnings（Unused disposable。The following is valid for the subscribe*, bind* and drive* family of functions that return Disposable.You will receive a warning for doing something such as this:） let xs:
RxSwift 介绍与简单使用
buyu03
07-13 2145
文章目录一、 Rx 介绍1、什么是Rx2、RxSwift3、RxCocoa二、Rx 常见用法1、给 button 添加点击事件（RxCocoa）2、事件 + bind + combine3、遵循代理并实现4、闭包回调5、通知6、多任务依赖关系管理7、多任务异步并行三、DisposeBag（清除包）介绍：四、函数式编程介绍参考文献： 一、 Rx 介绍 1、什么是Rx Rx 是 ReactiveX 的缩写，简单来说就是基于异步 Event 序列的响应式编程。Rx 可以简化异步编程方法，并提供更优雅的数据绑定，让
（1）RxSwift的基本用法
China_PengChao的专栏
07-22 422
为什么要学习RxSwift：1、复合- Rx就是和复合的代名词2、复⽤用-复⽤用性⽐比较强-代码量量降低3、清晰-因为声明都是不不可变更更，代码函数式编程可读性强4、易易⽤用-理理解容易易，还抽象的了了异步编程，统⼀一代码⻛风格5、稳定-因为Rx是完全通过单元测试的6、装逼-代码的逼格高。 项目下载请移步GitHub有详细的教程。附上GitHub地址：https://github.com/Rea...
树莓派4支持多大tf卡_树莓派raspberry4B入坑指南 part-0
weixin_39789101的博客
11-20 5936
本文是【树莓派raspberry4B入坑指南】系列 part-0。下一篇请看：树莓派raspberry4B入坑指南 part-1买了个树莓派4B，废话不多说，开干！制作镜像micro sd 卡一个，如下:树莓派镜像下载地址：https://www.raspberrypi.org/downloads/raspbian/ ，Buster是最新版本，最早发布于2019年7月，支持最新版4B。 这里有三个...
树莓派4b自带wifi_树莓派raspberry4B入坑指南 part-11 在命令行中设置wifi
weixin_39596835的博客
01-14 1871
好久没有更新树莓派，今天主要讲解下如何从命令行设置密码。在第一节讲解中(树莓派raspberry4B入坑指南 part-0)，我推荐过大家购买屏幕，这样可以比较方便的设置wifi。这一节主要试试如何从命令行进行设置，当然有能力的童鞋也可以直接参考官网，写得比较全面，附上链接：Setting up a wireless LAN via the command line​www.raspberrypi...
【iOS】仿知乎日报，RxSwift-Part1-首页搭建
maple_ye_1994的博客
10-21 1270
前言之前的几篇博客算是入门篇，那么这篇就是RxSwift的实战篇。由于对RxSwift的认识还不够深刻，所以项目中没有使用MVVM模型，以及编程思想也还没转变过来。该项目是参考https://github.com/kLike/ZhiHu-RxSwift实现的，最大的实现区别就是，我用的是纯代码实现，还有对网络请求的封装。此外，原项目中存在大量强解包，很容易crash。因此，我是在原来基础上，做了一些
RxSwift:RxSwift从入门到放弃，Swift+RxSwift， RxSwift入门教程
05-01
RxSwift 从前段时间开始接触RxSwift，跟着网上教程一点点的敲一些基础代码，慢慢地接触到越来越深的知识点，记录在此。 运行截图 002 003 004 005 006 007 008 009 学习RxSwift这条路还有很长，代码也会越写越长，与全部热爱学习的伙伴共勉。
RXSwift教程iOS Mac OS中使用RX函数式编程最新版本1.1
09-02
RXSwift教程，iOS，Mac OS中使用RX函数式编程，最新版本1.1版，非常好的教程。
RxSwift学习教程之基础篇
08-29
RxSwift是Swift函数响应式编程的一个开源库，由Github的ReactiveX组织开发，维护。下面这篇文章主要给大家介绍了关于RxSwift学习之基础篇的相关资料，文中通过示例代码介绍的非常详细，需要的朋友可以参考借鉴，下面来一起看看吧。
RxSwift-Tutorial:RxSwift 学习资料(学习教程、开源项目)
05-18
RxSwift-Tutorial RxSwift QQ 交流群: 424180219 Rx 教程 推荐 RxSwift进阶与实战 基于RxSwift的MVVMR架构(一)思想、基本原理及初步实现 一个基于MVVM架构模式的RxSwiftDemo，旨在掌握RxSwift较为进阶的内容 【漫谈】从项目实践走向RxSwift响应式函数编程 Coordinator 与 RxSwift 共同构建的 MVVM 架构 RxSwift系统教程播客 RxSwift的学习资料清单 RxSwift学习之旅 RxSwift: Transforming Operators in Practice RxSwift: Transforming Operators Raywenderlich RxSwift Reactive Programming with Swift RxSwift 开源项目 项目名: v2ex 预
Action:摘要要在RxSwift中执行的动作
04-29
行动 该库与一起使用，以在可观察对象之上提供抽象：动作。 采取一种行动是说“嘿，以后我需要您订阅此内容”的一种方式。 实际上，它涉及的更多。 动作接受workFactory ：一个需要一些输入并产生可观察值的闭包。 execute() ，它将其参数传递给此闭包并订阅该工作。 只能在“启用”时执行（如果未指定，则为true ）。 一次只执行一件事。 汇总各个执行中的下一个/错误事件。 哦，它与UIButton的结合非常快，非常酷。 它会管理按钮的启用状态，确保在工作完成时禁用按钮，所有这些 :thumbs_up: 用法 您必须传递一个工作workFactory ，该工作workFactory接受输入并返回一个Observable 。 这代表了一些需要完成的工作。 每当调用execute() ，您都会传递输入到工作工厂的输入。 该Action将预订可观察对象，并在其elements属性上发出Next事
【三维目标检测】Part-A2（一）
最新发布
叶子的博客
11-21 4584
Part-A2的整体结构如下图所示，主要包括Part-Aware stage 和Part-aggregation stage两个阶段。Part-Aware stage主要是提取点云中各个点的特征，包括语义分割特征和目标内部点的特征，提取特征的方法是一个采用三维稀疏卷积的UNET结构。UNET是二维图像语义分割中比较常见的一个主干网络结构，Part-A2沿用了这个结构，并且将二维卷积相应地替换成三维稀疏卷积。
完整英飞凌AURIX_TC3XX用户手册
05-04
总结，英飞凌AURIX TC3XX用户手册是开发者全面掌握这款微控制器的重要参考资料，从基本概念到具体实现，从硬件接口到软件开发，涵盖了所有关键知识点，对于理解和应用AURIX TC3XX微控制器具有极大的指导价值。
RxSwift教程（1）：Observable
kmyhy的专栏
12-22 967
概念 Observable 等同于 RAC 中的信号 RACSignal。它会发送 3 种事件： next completed error 事件 Event 是一种特殊的枚举，包含了上述 3 个值，其中 next 和 error 事件都会带一个参数，但 completed 事件没有参数： public enum Event<Element> { case next(Elem...
RxSwift极简入门
weixin_43148043的博客
05-16 767
RxSwift极简入门     关于RxSwift网上有多资料介绍，但部分来说很多都是关注于具体细节，以至于有一种看完有种似懂非懂的感觉。最近学习和使用了一段时间，这里写一下自己学习和使用的一些感受，不讨论具体的细节从整体上理解这个框架。 是什么     RxSwift根据中文文档介绍是一个用swift编写的函数式响应框架，这里有三个关键的点。 swift编写的，这意味着学习这个框架是需要一点swift语言基础的，它主要服务于swift编写的项目环境。 函数式，是一个比较抽象的概念这里简单的可以理解为可以
IEEE 802.3 Part 4-2008：10Gbps CSMA/CD标准与物理层详细规格
IEEE 802.3 Part 4-2008 Edition 是10Gbps以太网技术和标准的核心文档，它不仅定义了数据传输的高层协议规范，还提供了详细的物理层技术细节，为构建高效、兼容的10Gbps网络基础设施奠定了基础。这对于通信工程师、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值