MongoDB queries use operators (prefixed with $) to express conditions beyond simple equality — comparison, logical, element, and array operators. They're the building blocks of filter documents for finding the data you want.
db..({ : { : } });
db..({ : { : , : } });
db..({ : { : } });
db..({ : { : [, ] } });
db..({ : { : [] } });
$eq $ne → equal / not equal
$gt $gte → greater than / greater-or-equal
$lt $lte → less than / less-or-equal
$in $nin → in / not in a list of values
// $and / $or / $not / $nor combine conditions
db.users.find({ $or: [{ age: { $lt: 18 } }, { age: { $gt: 65 } }] }); // young OR old
db.users.find({ $and: [{ active: true }, { premium: true }] });
// (multiple fields in one filter are AND by default)
db.users.find({ active: true, age: { $gt: 18 } }); // active AND age > 18
Multiple fields in a filter are implicitly ANDed; $or/$and/$not express more complex logic.
db.users.find({ email: { $exists: true } }); // field exists
db.users.find({ age: { $type: "number" } }); // field is of a type
// array operators
db.posts.find({ tags: "mongodb" }); // array CONTAINS "mongodb"
db.posts.find({ tags: { $all: ["a", "b"] } }); // contains ALL of these
db.posts.find({ tags: { $size: 3 } }); // array has exactly 3 elements
db.posts.find({ "scores": { $elemMatch: { $gt: 80, $lt: 90 } } }); // an element matching
Array operators query inside arrays — $all (contains all), $size (length), $elemMatch (an element matching multiple conditions), and matching a value directly checks containment.
db.users.find({ "address.city": "NY" }); // query a NESTED field with dot notation
Query operators are essential for filtering data effectively in MongoDB — finding specific documents based on conditions is a constant need in any application, so understanding them is fundamental everyday knowledge.
Knowing the comparison operators ($gt, $lt, $in, etc. for ranges and value matching), logical operators ($or, $and, and that multiple filter fields are implicitly AND-ed), element operators ($exists, $type), and especially array operators ($all, $size, $elemMatch, and direct containment matching) covers the spectrum of query conditions you'll need.
The array operators are particularly important in MongoDB because documents commonly contain arrays (a key part of the document model), and querying inside them (containment, all-elements, element-matching) is a frequent need that distinguishes MongoDB querying.
Understanding dot notation for querying nested fields ("address.city") is also essential given MongoDB's nested document structure.
Since filtering data is one of the most common database operations, and since MongoDB's query operators (comparison, logical, element, and especially array operators, plus nested-field querying) are how you express the conditions to find the right documents, understanding the query operators is essential, frequently-applied MongoDB knowledge — the equivalent of mastering SQL's WHERE conditions, and necessary for writing effective queries against MongoDB's document and array-rich data, a core skill for any MongoDB development.