Ios 通过使用查询，而不是重复观察单个事件，加快获取我的社交网络应用程序的帖子

我有一组键，这些键指向我的社交网络的post对象，如so/posts/id/（post info）

当我加载帖子时，我使用

observeSingleEventOfType（.Value）

方法加载/posts/0，然后加载/posts/1等

我使用

lazyTableView

一次加载30个，速度相当慢。是否有任何方法可以使用其中一种查询方法或另一种方法使其更快，即使我必须重新构造JSON树中的数据

我正在重新实现我的应用程序，到目前为止，体验相当不错。就这件事我有点迷恋。提前感谢您的帮助

编辑：

func loadNext(i: Int) { 

    // check if exhists
    let ideaPostsRef = Firebase(url: "https://APPURL")

    ideaPostsRef.childByAppendingPath(i.description).observeSingleEventOfType(.Value, withBlock: {
        (snapshot) in

        if i % 29 == 0 && i != 0 && !self.hitNull { return }
            // false if nil
            // true if not nil
        if !(snapshot.value is NSNull) {
            let postJSON  = snapshot.value as! [String: AnyObject]
            print("GOT VALID \(postJSON)")
            let post = IdeaPost(message: postJSON["message"] as! String, byUser: postJSON["user"] as! String, withId: i.description)
            post.upvotes = postJSON["upvotes"] as! Int
            self.ideaPostDataSource.append(post)
            self.loadNext(i + 1)
        } else {
            // doesn't exhist
            print("GOT NULL RETURNING AT \(i)")
            self.doneLoading = true
            self.hitNull = true
            return
        }
    }
}

该递归函数本质上是从firebase获取键号i的值。如果它是NSNULL，它知道这是最后一个可能加载的post，并且不再加载。如果NSNULL没有被命中，但是

i%29==0

则它作为基本情况返回，因此一次只加载30篇文章（索引为0）。当我将

doneLoading

设置为

true

时，使用属性观察器调用

tableView.reloadData（）

下面是我正在获取的数组的示例

"ideaPosts" : [ {
    "id" : 0,
    "message" : "Test",
    "upvotes" : 1,
    "user" : "Anonymous"
  }, {
    "id" : 1,
    "message" : "Test2",
    "upvotes" : 1,
    "user" : "Anonymous"
  } ]

更新：我们现在也在一篇文章中讨论这个问题

从Firebase加载许多项目并不一定要慢，因为您可以通过管道处理请求。但是您的代码使这变得不可能，这确实会导致性能不理想

在代码中，您从服务器请求一个项目，等待该项目返回，然后加载下一个项目。在简化的序列图中，如下所示：

Your app                     Firebase 
                             Database

        -- request item 1 -->
                               S  L
                               e  o
                               r  a
                               v  d
                               e  i
        <-  return item  1 --  r  n
                                  g
        -- request item 2 -->
                               S  L
                               e  o
                               r  a
                               v  d
                               e  i
                               r  n
        <-  return item  2 --     g
        -- request item 3 -->
                 .
                 .
                 .
        -- request item 30-->
                               S  L
                               e  o
                               r  a
                               v  d
                               e  i
                               r  n
                                  g
        <-  return item 30 --

比较：在我的系统上顺序加载64个项目需要3.8秒，而管道加载（就像Firebase客户端本机那样）需要600毫秒。确切的数字将取决于您的连接（延迟和带宽），但流水线版本应该总是快得多。

更新：我们现在也在一篇文章中讨论这个问题

从Firebase加载许多项目并不一定要慢，因为您可以通过管道处理请求。但是您的代码使这变得不可能，这确实会导致性能不理想

在代码中，您从服务器请求一个项目，等待该项目返回，然后加载下一个项目。在简化的序列图中，如下所示：

Your app                     Firebase 
                             Database

        -- request item 1 -->
                               S  L
                               e  o
                               r  a
                               v  d
                               e  i
        <-  return item  1 --  r  n
                                  g
        -- request item 2 -->
                               S  L
                               e  o
                               r  a
                               v  d
                               e  i
                               r  n
        <-  return item  2 --     g
        -- request item 3 -->
                 .
                 .
                 .
        -- request item 30-->
                               S  L
                               e  o
                               r  a
                               v  d
                               e  i
                               r  n
                                  g
        <-  return item 30 --

---

比较：在我的系统上顺序加载64个项目需要3.8秒，而管道加载（就像Firebase客户端本机那样）需要600毫秒。确切的数字将取决于您的连接（延迟和带宽），但流水线版本应该总是快得多。

如果您向我们展示您的代码而不是描述代码，将更容易提供帮助。包括最小的JSON（作为文本，而不是屏幕截图）和代码来重现问题，我们可以看到如何改进它。阅读更多关于.Edited以包含代码解释的信息如果您向我们展示您的代码而不是对其进行描述，将更容易提供帮助。包括最小的JSON（作为文本，而不是屏幕截图）和代码来重现问题，我们可以看到如何改进它。阅读更多关于。编辑以包含代码解释尼斯，Puf！此外，如果您需要加载所有项目，但仍希望在采取某些操作之前并行获取它们，那么链接承诺（jQuery.whenAll（）、q.all（）或Promise.all（））在这里非常方便。酷。即使我一直在使用它，也没有想到这一点。：-）@FrankvanPuffelen从性能的角度来看，您是对的，但是如果其中一个调用由于任何类型的错误而没有返回，该怎么办？如果其中任何一个请求失败，您如何“取消”其余未决请求。在顺序请求的情况下，我们可以在代码中知道哪个请求失败了。请分享你的想法。谢谢。我们怎样才能做到承诺。都在安卓系统中？如何在androidI中加载所有数据我在这里看到了一些有希望的顶级结果：很好，Puf！此外，如果您需要加载所有项目，但仍希望在采取某些操作之前并行获取它们，那么链接承诺（jQuery.whenAll（）、q.all（）或Promise.all（））在这里非常方便。酷。即使我一直在使用它，也没有想到这一点。：-）@FrankvanPuffelen从性能的角度来看，您是对的，但是如果其中一个调用由于任何类型的错误而没有返回，该怎么办？如果其中任何一个请求失败，您如何“取消”其余未决请求。在顺序请求的情况下，我们可以在代码中知道哪个请求失败了。请分享你的想法。谢谢。我们怎样才能做到承诺。都在安卓系统中？我们如何在androidI中加载所有数据在这里可以看到一些有希望的顶级结果：

function loadVideosSequential(videoIds) {
  if (videoIds.length > 0) {
    db.child('videos').child(videoIds[0]).once('value', snapshot => {
      if (videoIds.length > 1) {
        loadVideosSequential(videoIds.splice(1), callback)
      }
    });
  }
}

function loadVideosParallel(videoIds) {
  Promise.all(
    videoIds.map(id => db.child('videos').child(id).once('value'))
  );
}