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

更新：我们现在也在 AskFirebase 剧集中介绍了这个问题。

从 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 --

在此方案中，你将等待往返时间的 30 倍 + 从磁盘加载数据所需时间的 30 倍。如果（为了简单起见）我们说往返需要 1 秒，而从磁盘加载项目也需要 1 秒，最少需要 30 * （1 + 1） = 60 秒。

在 Firebase 应用中，如果您一次性发送所有请求（或至少发送合理数量的请求），您将获得更好的性能：

Your app                     Firebase 
                             Database

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

如果我们再次假设往返 1 秒和加载 1 秒，则您正在等待 30*1 + 1 = 31 秒。

因此：所有请求都通过相同的连接。鉴于此，、、和之间的唯一区别是帧的一些开销。get(1)get(2)get(3)getAll([1,2,3])

我设置了一个 jsbin 来演示该行为。数据模型非常简单，但它展示了差异。

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'))
  );
}

相比之下：在我的系统上按顺序加载 64 个项目需要 3.8 秒，而通过管道加载它们（就像 Firebase 客户端本身所做的那样）需要 600 毫秒。确切的数字将取决于您的连接（延迟和带宽），但流水线版本应始终明显更快。