Firestore中如何一次性获取含子引用的对象及关联数据？

Absolutely! You don’t have to manually call get() on each reference one by one—Firebase offers a couple of clean, efficient ways to pull your main entry along with all its linked data in a single workflow. Let’s break down the solutions based on which Firebase database you’re using:

For Cloud Firestore #

1. Batched Document Reads #

Firestore lets you fetch up to 10 documents in one batch using the getAll() method. This cuts your network calls from N+1 to just 2 (one for the main document, one for the batch):

const db = firebase.firestore();

async function fetchMainWithReferences(mainDocId) {
  // Grab the main document first
  const mainDocRef = db.collection('mainCollection').doc(mainDocId);
  const mainDocSnap = await mainDocRef.get();
  
  if (!mainDocSnap.exists) {
    throw new Error('Main document not found');
  }
  
  const mainData = mainDocSnap.data();
  // Collect all reference fields from your document (adjust to your schema)
  const allReferences = [mainDocRef];
  if (mainData.userRef) allReferences.push(mainData.userRef);
  if (mainData.productRef) allReferences.push(mainData.productRef);
  
  // Fetch all documents in one batch
  const allDocsSnap = await db.getAll(...allReferences);
  
  // Combine results into a single object
  const combinedData = {};
  allDocsSnap.forEach(snap => {
    if (snap.id === mainDocId) {
      combinedData.main = snap.data();
    } else {
      // Match references to their data (customize based on your fields)
      if (snap.ref.path === mainData.userRef.path) {
        combinedData.user = snap.data();
      } else if (snap.ref.path === mainData.productRef.path) {
        combinedData.product = snap.data();
      }
    }
  });
  
  return combinedData;
}

2. Denormalize Data with Cloud Functions #

If you do this fetch pattern often, consider denormalizing your data. Use a Cloud Function to automatically embed referenced data into the main document whenever either the main document or linked data updates:

exports.syncReferencedDataToMainDoc = functions.firestore
  .document('mainCollection/{mainDocId}')
  .onWrite(async (change, context) => {
    const mainData = change.after.data();
    if (!mainData?.userRef) return;
    
    // Fetch the linked user data
    const userSnap = await mainData.userRef.get();
    if (userSnap.exists) {
      // Update the main document with embedded user data
      return change.after.ref.update({
        embeddedUserData: userSnap.data()
      });
    }
    return null;
  });

Now when you fetch the main document, it already has the linked data built-in—no extra get() calls required. Just add a second function to sync updates from the referenced data back to all related main documents if needed.

For Firebase Realtime Database #

In Realtime Database, references are just paths (strings or Reference objects). You can fetch multiple paths in parallel, and the database batches these into a single network request under the hood:

const db = firebase.database();

async function fetchMainWithReferences(mainDocPath) {
  // Get the main document
  const mainDocSnap = await db.ref(mainDocPath).once('value');
  const mainData = mainDocSnap.val();
  
  if (!mainData) throw new Error('Main document not found');
  
  // Collect all reference paths from your entry
  const refPaths = [
    mainDocPath,
    mainData.userRefPath,
    mainData.productRefPath
  ];
  
  // Fetch all paths in parallel
  const allSnapshots = await Promise.all(
    refPaths.map(path => db.ref(path).once('value'))
  );
  
  // Combine results into one object
  const combinedData = {
    main: allSnapshots[0].val(),
    user: allSnapshots[1].val(),
    product: allSnapshots[2].val()
  };
  
  return combinedData;
}

If your data structure allows it, the simplest fix is to nest the referenced data directly under the main entry. This lets you fetch everything in a single once('value') call—just be mindful of over-fetching if the nested data is large.

Pro tip: For super complex relationships, you could use a client-side data loader library to automate this, but the methods above are built-in, no-dependency solutions that work great for most use cases.

内容的提问来源于stack exchange，提问作者charles-emile begin lavigne