MongoDB中何时可省略$and操作符？其使用必要性探讨

Great questions about MongoDB's query behavior—let’s break this down with clear examples and practical context.

You can safely omit $and whenever you’re specifying multiple conditions targeting distinct field paths (either top-level fields or nested fields like grades.score or address.coord). MongoDB automatically treats these top-level key-value pairs as an implicit logical AND.

For your example query:

db.restaurants.find({ 
  "cuisine": {$ne: "American "}, 
  "grades.score": {$gt: 70}, 
  "address.coord": {$lt: -65.754168} 
});

Each condition targets a unique field path, so MongoDB internally evaluates them as if you’d wrapped them in an explicit $and—no need to write it out.

A simpler, relatable example:

// Implicit AND (works exactly like the explicit version below)
db.users.find({ age: {$gt: 18}, country: "Canada" })

// Explicit AND (same result, but redundant here)
db.users.find({ $and: [{ age: {$gt: 18} }, { country: "Canada" }] })

The key exception: You cannot omit $and when applying multiple conditions to the same field path, unless those conditions can be combined into a single operator. For example, if you want to find documents where age is between 18 and 30, you can combine the operators:

db.users.find({ age: {$gt: 18, $lt: 30} })

But if you need conflicting or non-combinable conditions on the same field (e.g., age exists AND is not equal to 25), you must use $and to avoid overwriting the field’s query object:

// Correct: Uses $and to apply two distinct rules to the same field
db.users.find({ $and: [{ age: {$exists: true} }, { age: {$ne: 25} }] })

// Incorrect: The second "age" key overwrites the first, only the $ne condition runs
db.users.find({ age: {$exists: true}, age: {$ne: 25} })

Readability is a huge benefit, but $and serves critical functional purposes beyond making queries easier to read:

• Applying multiple conditions to the same field: As noted above, this is the most common mandatory use case. When you can’t merge rules into a single operator, $and ensures all conditions on the field are respected.
• Combining complex nested conditions: When building queries with nested $or, $not, or $expr clauses, explicit $and removes ambiguity from the logical flow. For example:

  db.restaurants.find({
    $and: [
      {$or: [{ cuisine: "Italian" }, { cuisine: "French" }]},
      { "grades.score": {$avg: {$gt: 80}} }
    ]
  })
  

  While you could technically write this without $and, wrapping grouped conditions makes your intent immediately clear, especially for other developers reading your code.
• Dynamic query construction: If you’re building queries programmatically (e.g., based on user filters), using $and lets you safely add conditions as separate objects to an array. This eliminates the risk of overwriting existing keys if two conditions target the same field.
• Performance tuning (edge cases): While MongoDB’s query optimizer usually handles condition order efficiently, explicit $and can help you prioritize faster-evaluating conditions (like indexed checks) first, which can shave off latency in large datasets.

In short: Omit $and for simple, distinct-field queries to keep code clean, but reach for it when you need precision with same-field conditions, complex logic, or dynamic query building.

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