Firebase Firestore中collection().where()方法的功能、语法及示例代码解析

Hey there! Let's break down everything you need to know about Firestore's where() method, including that specific code snippet you shared.

The where() method is a core tool for filtering documents in a Firestore collection. Instead of fetching every document in a collection (which can be inefficient and costly), it lets you define conditions to only retrieve documents that match your criteria. This helps reduce bandwidth usage and speeds up your queries.

The method takes three required parameters, and you can chain multiple where() calls to add more filter conditions (just keep Firestore's query limitations in mind, like avoiding certain conflicting operator combinations):

• First parameter: fieldPath
  A string (or FieldPath object) that specifies the path to the field you want to filter on. This can be a top-level field like 'users' or a nested field like 'profile.contact.email'.
• Second parameter: opStr
  A string that defines the comparison logic between the field and your value. Firestore supports these operators:
  • ==: Equals
  • !=: Does not equal
  • <: Less than
  • <=: Less than or equal to
  • >: Greater than
  • >=: Greater than or equal to
  • array-contains: Checks if an array field includes the specified value
  • array-contains-any: Checks if an array field includes any value from a provided list
  • in: Checks if the field's value is in a provided list
  • not-in: Checks if the field's value is not in a provided list
• Third parameter: value
  The specific value to compare against the field. This must match the data type stored in the field (e.g., a string for a string field, a number for a numeric field) for the comparison to work correctly.

Let's walk through your line of code step by step:

const userExist = db.collection('data').where('users', 'array-contains', user.email);

1. db.collection('data'): This creates a reference to the Firestore collection named data. It doesn't fetch any data yet—it just points to the collection.
2. .where('users', 'array-contains', user.email): This adds a filter to the collection reference:
   • We're targeting the users field in each document of the data collection. This field must be stored as an array (if it's not an array, the query won't return any results).
   • The array-contains operator tells Firestore to only return documents where the users array includes the exact value of user.email (this is case-sensitive and type-sensitive—so a string email won't match a numeric value in the array).
3. Important note: The userExist variable is a query object, not the actual results. To get the data and check if the user exists, you need to call the get() method on it, like this:

   userExist.get().then((querySnapshot) => {
     if (!querySnapshot.empty) {
       // There's at least one document where the `users` array includes the email
       console.log("User exists in the data collection");
     } else {
       // No documents match the filter
       console.log("User does not exist");
     }
   }).catch((error) => {
     console.error("Error checking user existence:", error);
   });
   

内容的提问来源于stack exchange，提问作者Gourav Singh Rawat