Firebase:何时快速调用 removeObserverWithHandle [英] Firebase: when to call removeObserverWithHandle in swift

问题描述

文档说如果你不再需要观察者，你需要调用 observeEventType:withBlock 来移除观察者.

Documentation says you need to call observeEventType:withBlock to remove an observer if you no longer need it.

我见过在 ViewDidDisAppear 中调用它的示例.我还在 deinit 中找到了一些称为此方法的 Obj-C 代码，这在 Swift 中不是必需的.

I've seen samples where it is called within ViewDidDisAppear. I also find some Obj-C code called this method within deinit, which is not ncessary in Swift.

然而，在我的简单应用程序中，我希望只要我在应用程序中就可以同步数据.如果是这种情况，我是否必须调用 observeEventType:withBlock ?

In my simple app, however, I want data to be synced as long as I am in the app. If this is the case, do I have to call observeEventType:withBlock ever?

我在 Firebase 网站上查看了 Chat-Swift 示例代码，没有找到 observeEventType:withBlock.

I checked the Chat-Swift sample code on Firebase website, and did not find observeEventType:withBlock.

是不是说不调用observeEventType:withBlock: 就可以了.如果我希望观察者在应用程序正在使用时处于开启状态?

Does it mean it's ok not to call observeEventType:withBlock:. if I want the observer to be on when the app is in use?

谢谢.

更新

感谢杰伊和大卫.我认为在 ViewWillAppear 中观察并在 ViewDidDisappear 中删除它是有意义的.

Thanks to Jay and David. I see it makes sense to observe in ViewWillAppear and remove it in ViewDidDisappear.

但是，我使用 observeEventType 来监视节点的任何值更改，如果有任何更改，我会更新 UI.如果我把它放在 ViewWillAppear 中:

However, I am using observeEventType to monitor any value change to the node and would update UI if there is any. If i put it in ViewWillAppear:

 override func viewWillAppear(animated: Bool) {
    super.viewWillAppear(animated)

    ref.observeEventType(.Value, withBlock: { snap in {
      // **update UI if there is any Value change** 
    })
  }

将其放入 viewWillAppear 的问题在于，每次视图出现时都会调用它，而不管值是否更改.因此，每次返回视图时都会下载快照并且我的 UI 会刷新.这会适得其反.

The problem with putting it in viewWillAppear is that, it gets called every time the view appears, regardless of Value change or not. Because of this, the snapshot is downloaded and my UI gets refreshed every time I return to the view. This becomes counterproductive.

我也尝试过 ChildAdded/ChildRemoved，但是，它只返回最后一个节点，而不是来自我的参考的路径:

I have also tried ChildAdded/ChildRemoved, however, it only returns the last node, not the path from my ref:

例如，如果我添加到 ref/child1/child2/child3/value，ChildAdded 只会返回 child3/value.

For instance, if I add to ref/child1/child2/child3/value, ChildAdded would only return child3/value.

所以如果我必须观察价值，似乎把它放在 ViewDidLoad 更好?这样，它在视图加载时获取一次快照，并在每次更改时重复，但不会因为视图出现而获取快照.

So if I have to observe Value, it seems like putting it in ViewDidLoad is better? In this way, it gets the snapshot one time when the view loaded, and would repeat whenever there is a change, but would not obtain the snapshot just because the view appears.

推荐答案

以@Jay 的出色回答为基础:

To build upon @Jay's excellent answer:

在 UIViewController 中，创建一个引用作为属性.在 viewDidLoad 中初始化一个引用.观察 viewWillAppear 中的事件.移除 viewDidDisappear 中的观察者.

In a UIViewController, create a reference as a property. Initialize a reference in viewDidLoad. Observe events in viewWillAppear. Remove observers in viewDidDisappear.

class MyViewController: UIViewController {

  var ref: Firebase!

  // Called only on load, great place to initialize
  override func viewDidLoad() {
    super.viewDidLoad()
    ref = Firebase(url: "https://<YOUR-FIREBASE-APP>.firebaseio.com/updates")
  }

  // Can be called many times to go on screen
  // Syncing should only occur when on view to conserve memory
  override func viewWillAppear(animated: Bool) {
    super.viewWillAppear(animated)

    ref.observeEventType(.Value, withBlock: { snap in {
      // do something with the data 
    })
  }

  // Can be called many times to off screen
  // Remove observers on the ref to conserve memory
  override func viewDidDisappear(animated: Bool) {
    super.viewDidDisappear(animated)
    ref.removeAllObservers() 
  }

}

根据您的

The problem with putting it in viewWillAppear is that, it gets called every time the view appears, regardless of Value change or not. Because of this, the snapshot is downloaded and my UI gets refreshed every time I return to the view. This becomes counterproductive.

Firebase 专为速度而生.这些是您留给客户的事情，因为它有几个功能可以处理这些情况.

Firebase is built for speed. These are the kind of things that you leave up to the client because it has several features that handle these situations.

Firebase 客户端具有内置缓存.除非您在 viewDidAppear 中下载一兆字节的数据，否则更新是名义上的.当观察者触发 viewDidAppear 并不一定意味着它正在再次下载数据.viewDidAppear 函数是您的观察者所属的地方.

The Firebase client has built-in caching. Unless you're downloading a megabyte of data in viewDidAppear the update is nominal. When the observer fires on viewDidAppear it doesn't necessarily mean it's downloading the data again. The viewDidAppear function is where your observers belong.

仅供参考，我是一名在 iOS 上工作的 Firebase 员工.

FYI, I am a Firebase employee who works on iOS.

这篇关于Firebase:何时快速调用 removeObserverWithHandle的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！