如何使用Swift从Firebase获取随机对象？含序列ID生成方法

我太懂你这种找不到便捷方案的苦恼了！之前折腾Firebase随机查询的时候也踩过不少坑，给你分享两个亲测好用的方案，不管是生成序列ID还是直接取随机对象都能解决：

方案一：通过自增序列ID实现随机查询 #

这个方案的核心是给每条记录分配一个连续的序列ID，之后通过生成随机数直接定位到对应ID的记录。

步骤1：创建自增ID生成逻辑 #

Firebase本身没有内置的自增ID，但可以通过原子计数器实现：

1. 先在数据库里创建一个counter节点，初始值设为0；
2. 每次创建新记录时，先对计数器执行原子递增操作，拿到最新的计数作为序列ID。

Swift代码实现：

import FirebaseDatabase

// 获取计数器引用
let counterRef = Database.database().reference().child("counter")

// 原子递增计数器并创建新记录
counterRef.runTransactionBlock({ (currentData: MutableData) -> TransactionResult in
    var currentCount = currentData.value as? Int ?? 0
    currentCount += 1
    currentData.value = currentCount
    return TransactionResult.success(withValue: currentData)
}) { (error, committed, snapshot) in
    guard let newCount = snapshot?.value as? Int, committed, error == nil else {
        print("生成序列ID失败：\(error?.localizedDescription ?? "未知错误")")
        return
    }
    
    // 用新生成的序列ID创建记录
    let newRecordRef = Database.database().reference().child("records").child("\(newCount)")
    newRecordRef.setValue([
        "title": "示例记录",
        "content": "这是第\(newCount)条记录"
    ])
}

步骤2：查询随机对象 #

先获取计数器的最大值，生成一个1到最大值之间的随机数，直接查询对应ID的记录即可：

counterRef.observeSingleEvent(of: .value) { snapshot in
    guard let maxCount = snapshot.value as? Int, maxCount > 0 else {
        print("没有可用记录")
        return
    }
    
    let randomId = Int.random(in: 1...maxCount)
    let randomRecordRef = Database.database().reference().child("records").child("\(randomId)")
    
    randomRecordRef.observeSingleEvent(of: .value) { recordSnapshot in
        if let record = recordSnapshot.value as? [String: Any] {
            print("随机获取到的记录：\(record)")
        } else {
            // 如果该ID对应的记录已被删除，重新生成随机数查询
            print("记录不存在，重新查询...")
            // 这里可以递归调用查询逻辑，或者加个重试次数限制
        }
    }
}

注意点 #

如果有记录被删除，会出现ID断层，这时候可以加个重试逻辑（比如查询不到就重新生成随机数），或者额外维护一个有效ID的列表（适合记录频繁删除的场景）。

方案二：无需序列ID，直接获取随机对象（更简便） #

如果不想维护计数器，这两个方法更省心：

方法A：小数据量场景 - 获取所有记录Key后随机选择 #

适合记录数量不多的情况，直接获取所有记录的Key数组，随机选一个再查询对应记录：

let recordsRef = Database.database().reference().child("records")

recordsRef.observeSingleEvent(of: .value) { snapshot in
    guard let allRecords = snapshot.value as? [String: Any], !allRecords.isEmpty else {
        print("没有可用记录")
        return
    }
    
    let recordKeys = Array(allRecords.keys)
    guard let randomKey = recordKeys.randomElement() else { return }
    
    let randomRecordRef = recordsRef.child(randomKey)
    randomRecordRef.observeSingleEvent(of: .value) { recordSnapshot in
        if let record = recordSnapshot.value as? [String: Any] {
            print("随机记录：\(record)")
        }
    }
}

方法B：大数据量场景 - 用随机数字段查询 #

给每条记录添加一个randomNumber字段（0到1之间的随机浮点数），创建记录时自动生成：

let newRecord = [
    "title": "大数据量示例记录",
    "content": "带随机数字段的记录",
    "randomNumber": Double.random(in: 0...1)
]

recordsRef.childByAutoId().setValue(newRecord)

查询时生成一个0到1的随机数，通过queryStarting(atValue:)获取第一个匹配的记录；如果随机数比所有记录的randomNumber都大，就取第一条记录：

let randomVal = Double.random(in: 0...1)

recordsRef.queryOrdered(byChild: "randomNumber")
          .queryStarting(atValue: randomVal)
          .queryLimited(toFirst: 1)
          .observeSingleEvent(of: .value) { snapshot in
              if snapshot.exists() {
                  // 拿到随机记录
                  if let recordSnapshot = snapshot.children.allObjects.first as? DataSnapshot,
                     let record = recordSnapshot.value as? [String: Any] {
                      print("随机记录：\(record)")
                  }
              } else {
                  // 随机数超出范围，取第一条记录
                  recordsRef.queryOrdered(byChild: "randomNumber")
                            .queryLimited(toFirst: 1)
                            .observeSingleEvent(of: .value) { firstSnapshot in
                                if let recordSnapshot = firstSnapshot.children.allObjects.first as? DataSnapshot,
                                   let record = recordSnapshot.value as? [String: Any] {
                                    print("随机记录：\(record)")
                                }
                            }
              }
          }

这个方案不用加载所有记录，性能更优，适合记录数量较多的场景。

内容的提问来源于stack exchange，提问作者user1602074