Question

所以基本上我有一个结构

struct MyStruct {
    var foo : String = "" 
    var bar : String = ""
}

现在我要做以下事情：观察MyStruct的RxVariable中的变化，这样每当变量变化时，我们也有一个观察者到那个变量，我们将能够在该观察者中获得新的结构。

再次明确 -

A类

var stct : Variable<MyStruct>() // RxSwift variable

B类：

 let observer = instanceClassA.stct.asObserver().subscribe(onNext : 
  {(newStruct) in 
       // newStruct found here -
  }
 observer.dispose(by:disposeBag)

我想要这个流程的原因是：我希望Class B知道Class A's的{{1}}变量何时更改了新值，因为每次myStruct变量都会发生变化{ {1}}和myStruct也会更改

认为B类是myStruct的A类变量的观察者。现在我正在学习RxSwift因此我想利用它的反应性方法。另外我认为这是一件相当容易的事情，但问题是我不能foo bar

P.S - 我使用的是Swift 4.0和RxSwift的最新版本。

非常感谢任何帮助。

Answer 1

为什么不使用distinctUntilChanged运算符？

您可以使结构符合Equatable，distinctUntilChanged运算符将以这种方式运行：

struct MyStruct: Equatable {

    var foo : String = ""
    var bar : String = ""

    static func ==(lhs: MyStruct, rhs: MyStruct) -> Bool {
        return lhs.bar == rhs.bar && lhs.foo == rhs.foo
    }
}

func observableStctChangedByEquatable() -> Observable<MyStruct> {
    return stct
        .asObservable()
        .distinctUntilChanged()
}

let observer = instanceClassA
    .observableStctChangedByEquatable()
    .subscribe(onNext: { (newStruct) in
        //
    })

如果您不喜欢Equatable，还有其他一些方法可以使用distinctUntilChanged运算符。选择你最喜欢的那个：

struct MyStruct {

    var foo : String = ""
    var bar : String = ""

    static func comparer(lhs: MyStruct, rhs: MyStruct) throws -> Bool {
        return lhs.bar == rhs.bar && lhs.foo == rhs.foo
    }
}

func observableStctChangedByComparer() -> Observable<MyStruct> {
    return stct
        .asObservable()
        .distinctUntilChanged(MyStruct.comparer)
}

func observableStctChangedByBlock() -> Observable<MyStruct> {
    return stct
        .asObservable()
        .distinctUntilChanged({ (lhs, rhs) -> Bool in
            return lhs.bar == rhs.bar && lhs.foo == rhs.foo
        })
}

func observableStctChangedWith(comparer: @escaping (MyStruct, MyStruct) throws -> Bool) -> Observable<MyStruct> {
    return stct
        .asObservable()
        .distinctUntilChanged(comparer)
}

let observer = instanceClassA
    .observableStctChangedWith(comparer: { (lhs, rhs) -> Bool in
        return lhs.bar == rhs.bar && lhs.foo == rhs.foo
    })
    .subscribe(onNext: { (newStruct) in
        //
    })

RXSwift，一个结构作为变量

1 个答案: