如何从Firestore获取随机数据？游戏房间双用户同步获取优化咨询

Hey there! Let's tackle your Firestore questions with practical, scalable solutions that fix the pain points of your current setup.

Your current approach relies on a manually maintained array of numbers, which is error-prone when adding new questions. Here are a few better ways to fetch random documents from Firestore:

Option 1: Add a random number field to your question documents #

For each question document, add a randomFloat field (type: Float) with a value between 0 and 1 (you can generate this when creating the question). Then, to fetch a random question:

1. Generate a random float between 0 and 1 in your client code
2. Query for documents where randomFloat is greater than your generated value, limit to 1
3. If no results come back (you hit the end of the collection), query for documents where randomFloat is less than your generated value instead

This method is efficient even with large collections, since you can index the randomFloat field for fast queries.

Option 2: Dynamic count + offset (small collections only) #

If your question set is small (a few hundred documents max), you can first get the total number of questions, generate a random index, then use offset() to fetch that document:

let questionsRef = db.collection("QUESTIONS_Collection")
questionsRef.getDocuments { snapshot, error in
    guard let count = snapshot?.count, count > 0 else { return }
    let randomIndex = Int.random(in: 0..<count)
    questionsRef.limit(to: 1).offset(randomIndex).getDocuments { qSnapshot, _ in
        guard let randomQuestion = qSnapshot?.documents.first else { return }
        // Process your question data here
    }
}

Note: offset() is inefficient for large collections, since Firestore has to skip every document before your target index. Stick with the random float method if you have thousands of questions.

The key here is ensuring both users get the same random question (I assume that's your goal for a two-player game) and eliminating the need for manual array updates. Here's a robust approach:

Step 1: Ditch the manual array—dynamically fetch question count #

Instead of hardcoding an array, pull the total number of questions directly from Firestore whenever you need to generate a random question. This automatically adapts when you add new questions.

Step 2: Sync the random question via the room document #

To make sure both users get the same question, store the selected question's ID in your room document (ROOMS_Collection/{documentID}) and have both clients listen for changes to this field. Here's how to implement this:

Client-side logic (either user can trigger this):

func fetchAndSyncRandomQuestion() {
    let roomRef = db.collection("ROOMS_Collection").document(GameData.shared.documentID)
    let questionsRef = db.collection("QUESTIONS_Collection")

    // First, get total question count
    questionsRef.getDocuments { snapshot, error in
        guard let count = snapshot?.count, count > 0 else {
            print("No questions found")
            return
        }

        // Generate random index and fetch question
        let randomIndex = Int.random(in: 0..<count)
        questionsRef.limit(to: 1).offset(randomIndex).getDocuments { qSnapshot, _ in
            guard let questionDoc = qSnapshot?.documents.first else { return }
            let questionId = questionDoc.documentID

            // Write the selected question ID to the room document
            roomRef.updateData(["currentQuestionId": questionId]) { error in
                if let error = error {
                    print("Failed to update room: \(error.localizedDescription)")
                }
            }
        }
    }
}

Both clients listen for the room's current question:

func listenForRoomQuestion() {
    let roomRef = db.collection("ROOMS_Collection").document(GameData.shared.documentID)
    roomRef.addSnapshotListener { snapshot, error in
        guard let data = snapshot?.data(), let questionId = data["currentQuestionId"] as? String else { return }

        // Fetch the full question data using the ID
        db.collection("QUESTIONS_Collection").document(questionId).getDocument { qSnapshot, _ in
            guard let questionData = qSnapshot?.data() else { return }
            // Display the question to the user
        }
    }
}

Bonus: Use Cloud Functions for guaranteed consistency #

If you want to avoid race conditions (e.g., both users trying to generate a random question at the same time), move the random question generation to a Cloud Function. Trigger it when the room is created or when a new round starts, and have the function write the question ID to the room document. This ensures only one random question is generated per round.

内容的提问来源于stack exchange，提问作者Tom B.