如何在Firestore中高效获取与当前用户至少有3个共同兴趣的用户？

要实现直接从Firebase查询与当前用户至少有3个共同兴趣的用户，避免全量获取用户后过滤，需要利用Firestore的查询特性并结合组合查询的思路，具体步骤如下：

核心思路 #

Firestore无法直接查询数组交集的数量，但可以通过生成当前用户兴趣的所有3元素组合，然后查询包含任意一个组合全部元素的用户——只要用户包含其中一组3个兴趣，就说明与当前用户的共同兴趣至少有3个。

实现步骤与代码 #

1. 先获取当前用户的兴趣列表 #

首先需要拿到当前用户的interests数组，确保其长度≥3（否则没有符合条件的用户）。

2. 生成兴趣的3元素组合 #

编写工具函数生成当前用户兴趣的所有3元素组合，同时实现数组分块（因为Firestore的OR查询最多支持10个条件）。

3. 构建组合查询并合并结果 #

对每个组合构建AND查询（要求用户兴趣包含该组合的所有3个元素），再将多个AND查询通过OR组合，分批执行后去重结果。

完整代码实现：

// 生成数组的所有指定大小的组合
func generateCombinations<T>(from array: [T], size: Int) -> [[T]] {
    guard size <= array.count, size > 0 else { return [] }
    if size == array.count { return [array] }
    if size == 1 { return array.map { [$0] } }
    
    var result: [[T]] = []
    let rest = Array(array.dropFirst())
    let subCombos = generateCombinations(from: rest, size: size - 1)
    result += subCombos.map { [array[0]] + $0 }
    result += generateCombinations(from: rest, size: size)
    return result
}

// 数组分块扩展，用于分批处理查询条件
extension Array {
    func chunked(into size: Int) -> [[Element]] {
        return stride(from: 0, to: count, by: size).map {
            Array(self[$0..<Swift.min($0 + size, count)])
        }
    }
}

// 获取匹配用户的核心方法
func fetchMatchedUsers() {
    guard let currentUid = UserViewModel.shared.currentSession?.uid else { return }
    
    // 1. 获取当前用户的兴趣列表
    db.collection(Constants.Firebase.usersDB).document(currentUid).getDocument { [weak self] snapshot, error in
        guard let self = self else { return }
        if let error = error {
            self.errorService = .error(message: error.localizedDescription)
            return
        }
        
        guard let currentUser = try? snapshot?.data(as: User.self), 
              let currentInterests = currentUser.interests, 
              currentInterests.count >= 3 else {
            self.matchedUsers = []
            return
        }
        
        // 2. 生成所有3元素兴趣组合
        let interestCombos = self.generateCombinations(from: currentInterests, size: 3)
        // 分块处理，适配Firestore OR查询的10个条件限制
        let queryBatches = interestCombos.chunked(into: 10)
        
        var allMatchedUsers: [User] = []
        var completedBatches = 0
        
        // 3. 分批执行OR查询
        for batch in queryBatches {
            var orQueries: [Query] = []
            for combo in batch {
                // 构建单个组合的AND查询：用户兴趣必须包含该组合的所有3个元素
                let comboQuery = self.db.collection(Constants.Firebase.usersDB)
                    .whereField("id", isNotEqualTo: currentUid)
                    .whereField("interests", arrayContains: combo[0])
                    .whereField("interests", arrayContains: combo[1])
                    .whereField("interests", arrayContains: combo[2])
                orQueries.append(comboQuery)
            }
            
            // 合并为OR查询，执行获取结果
            let finalQuery = self.db.collection(Constants.Firebase.usersDB).whereFilter(Filter.orQuery(orQueries))
            finalQuery.getDocuments { [weak self] snapshot, error in
                guard let self = self else { return }
                completedBatches += 1
                
                if let error = error {
                    self.errorService = .error(message: error.localizedDescription)
                    return
                }
                
                guard let docs = snapshot?.documents else { return }
                do {
                    let users = try docs.compactMap({ try $0.data(as: User.self) })
                    // 去重：同一用户可能匹配多个组合
                    users.forEach { user in
                        if !allMatchedUsers.contains(where: { $0.id == user.id }) {
                            allMatchedUsers.append(user)
                        }
                    }
                    
                    // 所有批次完成后更新数据
                    if completedBatches == queryBatches.count {
                        self.matchedUsers = allMatchedUsers
                    }
                } catch {
                    self.errorService = .error(message: error.localizedDescription)
                }
            }
        }
    }
}

注意事项 #

• 兴趣数量限制：如果当前用户的兴趣少于3个，直接返回空数组即可。
• 查询批次限制：Firestore的OR查询最多支持10个条件，因此需要将组合分块处理。
• 结果去重：同一用户可能匹配多个兴趣组合，必须通过id去重避免重复。
• 性能优化：如果当前用户兴趣数量过多（比如超过15个），组合数会急剧增加，建议只取前N个高频兴趣生成组合，平衡查询性能与匹配精度。
• 分页支持：若匹配用户数量较多，可在每个组合查询中添加分页逻辑（如start(afterDocument:)），避免一次性加载大量数据。

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