RXSwift，作为变量的结构体

Posted 2023-03-10

【中文标题】RXSwift，作为变量的结构体

【英文标题】：RXSwift, a Struct as a Variable

【发布时间】：2018-01-04 10:44:18

【问题描述】：

所以基本上我有一个结构

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 知道myStruct 的Class A's 变量何时更改为新值，因为每次myStruct 变量更改时，foo 和bar 将也变了

认为 B 类是 A 类变量 myStruct 的观察者。现在我正在学习 RxSwift，因此我想利用它的反应性方法。另外我认为这是一件相当容易的事情，但问题是我无法制作Variable (read : Rx) 的MyStruct

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

非常感谢任何帮助。

【问题讨论】：

是为 stct 变量分配了一个全新的 struct 实例，还是您只是修改了现有 stct 实例的 foo 和 bar 属性的值

可以两者兼有，根据一定的逻辑，是否可以从同一个api观察两种变化？

看看这个***.com/questions/36460542/…

您可以为 foo 和 bar 的值添加观察者，然后使用 scan 组合两个观察者并创建一个可以订阅的新 observable。因此，无论您更改 foo 还是 bar，您的订阅者都会被触发 :)。最后将 MyStruct 更改为 class 以通过分配 MyStruct 的新实例来观察更改

我已经看到了，但这反过来将结构内的变量作为可观察的，但我希望观察整个结构变量

【参考方案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
        //
    )