Firestore addSnapshotListener新增对象时替换原有数据的问题

Hey there! Let's fix that frustrating issue where your existing posts get replaced every time a new one comes in via Firestore's snapshot listener.

What's causing the problem? #

Right now, every time the snapshot updates, you're generating a brand new array of Post models from the full snapshot and directly replacing self.posts with it. Firestore's snapshot returns the entire current state of the collection (including new, modified, and deleted documents), so this full overwrite wipes out your existing data each time.

Solution 1: Only add new posts (simple version) #

If you just want to append new posts without losing existing ones, you can filter out posts you already have by their document ID and merge the new ones into your array.

First, make sure your Post model includes an id property that maps to the Firestore document ID (you'll need to adjust your initializer to capture this):

struct Post {
    let id: String
    // Your other post properties (postTimestamp, content, etc.)
    
    init?(dictionary: [String: Any], id: String) {
        self.id = id
        // Initialize your other properties from the dictionary
        guard let timestamp = dictionary["postTimestamp"] as? Timestamp else { return nil }
        self.postTimestamp = timestamp.dateValue()
        // ... rest of your init logic
    }
}

Then update your listener to merge new posts:

func observePosts() { 
    let postReference = Firestore.firestore().collection("Posts").limit(to: 20).order(by: "postTimestamp", descending: true)
    postReference.addSnapshotListener { (snapshot, error) in
        if let error = error {
            print(error)
            return
        }
        guard let snapshot = snapshot else { return }
        
        // Get IDs of posts we already have to avoid duplicates
        let existingPostIds = Set(self.posts.map { $0.id })
        
        // Filter out posts we already have, and initialize with document ID
        let newPosts = snapshot.documents
            .compactMap { doc in
                Post(dictionary: doc.data(), id: doc.documentID)
            }
            .filter { !existingPostIds.contains($0.id) }
        
        // Merge new posts at the front (since we're sorting by descending timestamp)
        self.posts = newPosts + self.posts
        
        // Update UI on main thread
        DispatchQueue.main.async {
            self.feedCollection.reloadData()
        }
    }
}

Solution 2: Handle all document changes (robust version) #

If you want to fully sync your local array with Firestore (including handling modified or deleted posts), use snapshot.documentChanges to process each individual update:

func observePosts() { 
    let postReference = Firestore.firestore().collection("Posts").limit(to: 20).order(by: "postTimestamp", descending: true)
    postReference.addSnapshotListener { (snapshot, error) in
        if let error = error {
            print(error)
            return
        }
        guard let snapshot = snapshot else { return }
        
        // Process each change type
        for change in snapshot.documentChanges {
            guard let updatedPost = Post(dictionary: change.document.data(), id: change.document.documentID) else {
                continue
            }
            
            switch change.type {
            case .added:
                // Insert new posts at the front (matches our descending sort)
                self.posts.insert(updatedPost, at: 0)
            case .modified:
                // Replace the existing post with the updated version
                if let index = self.posts.firstIndex(where: { $0.id == updatedPost.id }) {
                    self.posts[index] = updatedPost
                }
            case .removed:
                // Delete the post from our local array
                self.posts.removeAll(where: { $0.id == updatedPost.id })
            }
        }
        
        // Refresh the UI
        DispatchQueue.main.async {
            self.feedCollection.reloadData()
        }
    }
}

This second approach ensures your local data stays perfectly in sync with Firestore, handling every type of collection change without overwriting your existing posts.

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