Firestore数组项存前查重优化：现有循环查询是否有更优方案？

嘿，这个问题问得很到位！你现在的写法虽然能实现需求，但确实有不少可以优化的空间——最明显的就是每次循环都发起独立的读请求，不仅会增加整体延迟，还会消耗更多的数据库资源，甚至在高并发场景下可能出现竞态条件（比如两个请求同时判断某个item不存在，结果都执行了添加操作）。

下面给你几个更高效的实现思路，你可以根据自己的场景选择：

1. 优先用「自定义文档ID」替代自动ID（最优方案） #

如果你的item本身可以作为唯一标识（不会重复），那直接把它设为文档的ID，然后用set()方法来写入，根本不需要提前查询！

Firestore的set()方法默认是「文档不存在就创建，存在就覆盖」，但我们可以通过{ merge: false }参数让它只在文档不存在时写入，如果文档已经存在就直接跳过（或者捕获重复错误忽略即可）。

代码示例：

for (let item of items) {
  // 用item作为文档ID
  const docRef = db.collection('collection').doc(item);
  try {
    // merge: false 表示只有文档不存在时才写入
    await docRef.set(somethingToInsert, { merge: false });
  } catch (error) {
    // 捕获「文档已存在」的错误，直接忽略即可
    if (error.code === 'already-exists') {
      console.log(`Item ${item} 已存在，跳过`);
    } else {
      throw error;
    }
  }
}

这个方案的优势太明显了：

• 去掉了所有的读请求，每个item只需要一次写操作，性能提升巨大
• 天然避免竞态条件，因为Firestore的写入操作是原子性的

2. 批量查询+批量写入（无法用自定义ID时的次优选择） #

如果你的业务场景不允许用item作为文档ID，那可以把多次读请求合并成批量查询，再把需要添加的内容批量写入，减少网络往返次数。

注意Firestore的in操作符最多支持10个值，所以如果你的items数量超过10，要拆分批次处理：

const batchSize = 10; // Firestore in查询的上限是10个元素
for (let i = 0; i < items.length; i += batchSize) {
  const currentBatch = items.slice(i, i + batchSize);
  
  // 批量查询当前批次中已存在的item
  const existingSnap = await db.collection('collection')
    .where('property', 'in', currentBatch)
    .get();
  
  // 把已存在的property存入Set，方便快速判断
  const existingItems = new Set();
  existingSnap.forEach(doc => {
    existingItems.add(doc.data().property);
  });
  
  // 创建批量写入对象
  const batch = db.batch();
  currentBatch.forEach(item => {
    if (!existingItems.has(item)) {
      const newDocRef = db.collection('collection').doc(); // 自动生成ID
      // 注意：这里的somethingToInsert要对应当前item的内容，别写错了
      batch.set(newDocRef, { property: item, ...其他字段 });
    }
  });
  
  // 提交批量写入
  await batch.commit();
}

这个方案把N次读请求变成了Math.ceil(items.length/10)次，写请求也合并成批量操作，整体效率比你原来的写法高很多。唯一要注意的是：如果在「查询完成」和「批量写入」之间，有其他请求添加了相同的item，还是可能出现重复，所以如果需要严格保证唯一性，建议结合事务或者用第一个方案。

3. 事务（严格原子性需求时用） #

如果你的业务必须严格保证「先检查存在性，再写入」的原子性（比如绝对不能出现重复），那可以用Firestore的事务。不过事务适合单个或少量操作，批量处理的话性能会比较差，因为每个事务都是独立的请求：

for (let item of items) {
  await db.runTransaction(async (transaction) => {
    // 查询是否存在该item（limit(1)避免多余数据读取）
    const queryRef = db.collection('collection')
      .where('property', '==', item)
      .limit(1);
    const snap = await transaction.get(queryRef);
    
    if (snap.size === 0) {
      // 不存在则写入
      transaction.set(db.collection('collection').doc(), { property: item, ...其他字段 });
    }
  });
}

这个方案能彻底避免竞态条件，但性能是三个方案里最差的，只适合必须严格保证原子性的少量操作场景。

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