Logische Operatoren: $and, $or, $nor, $not
Kombinieren Sie mehrere Bedingungen mit logischen Operatoren, um komplexe Filterlogik auszudrücken.
Logische Operatoren: $and, $or, $nor, $not ist eine kostenlose MongoDB Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des MongoDB Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der MongoDB Academy-Kurs umfasst insgesamt 4 Lektionen.
Warum logische Operatoren erforderlich sind
Die meisten Abfragefilter enthalten Bedingungen für mehrere Felder, und nicht alle sollten mit einem einfachen AND kombiniert werden. Manchmal benötigen Sie Dokumente, die eine beliebige von mehreren Bedingungen erfüllen, oder Sie möchten Dokumente ausschließen, die einem Muster entsprechen. MongoDBs logische Operatoren – $and, $or, $nor und $not – geben Ihnen vollständige boolesche Kontrolle über Ihre Filterbedingungen.
Wenn Sie wissen, wann welcher Operator verwendet wird und wie die Abkürzung für das implizite AND funktioniert, werden Ihre Abfragen lesbarer und leistungsfähiger.
Implizites AND: Der Standard
Wenn Sie mehrere Feldbedingungen in einem einzigen Filterobjekt auflisten, wendet MongoDB sie als implizites AND an – alle Bedingungen müssen erfüllt sein, damit ein Dokument übereinstimmt. Dies ist der Standardfall und zugleich der häufigste.
Das implizite AND ist sowohl kürzer als auch etwas effizienter als der explizite Operator $and, weil MongoDB Bedingungen auf Feldebene unabhängig voneinander optimieren kann. Verwenden Sie das implizite AND immer dann, wenn Ihre Bedingungen auf unterschiedliche Felder abzielen und keine Mehrdeutigkeit besteht.
// Implicit AND - all three conditions must be true
db.users.find({
age: { $gte: 18 },
active: true,
role: 'user'
});
// Equivalent to: age >= 18 AND active = true AND role = 'user'
// Same with explicit $and (more verbose, same result)
db.users.find({
$and: [
{ age: { $gte: 18 } },
{ active: true },
{ role: 'user' }
]
});Wann Sie ein explizites $and benötigen
Ein explizites $and ist in einer bestimmten Situation erforderlich: wenn Sie mehrere Bedingungen auf dasselbe Feld mit unterschiedlichen Operatoren anwenden müssen und diese nicht in einem einzigen Objekt ausdrücken können (da JavaScript-Objekte keine doppelten Schlüssel enthalten können).
Der häufigste Fall ist die Kombination zweier $or-Bedingungen, die beide auf das Feld verweisen. Bereichsbedingungen für ein einzelnes Feld ({ price: { $gte: 20, $lte: 100 } }) funktionieren dagegen problemlos in einem Objekt – ein explizites $and ist nur erforderlich, wenn sich die Ausdrücke nicht zu einem einzigen Feldwert kombinieren lassen.
// Explicit $and: two $or conditions that cannot be merged
db.products.find({
$and: [
{ $or: [{ category: 'Electronics' }, { category: 'Computers' }] },
{ $or: [{ brand: 'Apple' }, { brand: 'Samsung' }] }
]
});
// (category is Electronics OR Computers)
// AND (brand is Apple OR Samsung)
// If you just wrote { $or: [...], $or: [...] }
// JS would only keep the last $or!$or: Mindestens eine Bedingung
$or nimmt ein Array von Filterbedingungen entgegen und findet Dokumente, bei denen mindestens eine der Bedingungen erfüllt ist. In MongoDB entspricht dies dem SQL-Schlüsselwort OR.
Verwenden Sie $or, wenn es alternative Wege zum selben Ergebnis gibt – zum Beispiel bei der Suche nach Benutzern, die entweder Administratoren sind oder in den letzten 30 Tagen aktiv waren. Ein wichtiger Hinweis zur Performance: Wenn jede Bedingung separat indiziert ist, kann MongoDB eine Indexvereinigung verwenden, um die Abfrage zu erfüllen. Ein einzelner zusammengesetzter Index, der alle Bedingungen abdeckt, ist jedoch häufig schneller.
// Find users who are admins OR have been recently active
const recentDate = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
db.users.find({
$or: [
{ role: 'admin' },
{ lastLoginAt: { $gte: recentDate } }
]
});
// Find products on sale OR low in stock
db.products.find({
$or: [
{ onSale: true },
{ stock: { $lt: 5 } }
]
});$nor: Keine der Bedingungen
$nor findet Dokumente, bei denen keine der angegebenen Bedingungen erfüllt ist – es bildet das Gegenstück zu $or. Ein Dokument muss ALLE Bedingungen im $nor-Array nicht erfüllen, damit es zurückgegeben wird.
$nor wird seltener als $or verwendet, ist aber für Ausschlusslogik nützlich: „Finde Produkte, die weder eingestellt noch nicht vorrätig sind und auch nicht zur archivierten Kategorie gehören.“ Außerdem werden Dokumente gefunden, bei denen die abgefragten Felder fehlen, da fehlende Felder keine positive Bedingung erfüllen.
// Exclude multiple status values
db.orders.find({
$nor: [
{ status: 'cancelled' },
{ status: 'refunded' },
{ status: 'archived' }
]
});
// Matches orders where status is NONE of the above
// (equivalent to status NOT IN [...])
// Could also write as:
db.orders.find({ status: { $nin: ['cancelled', 'refunded', 'archived'] } });$not: Einen einzelnen Operator negieren
$not kehrt das Ergebnis eines einzelnen Ausdrucks mit einem Operator auf Feldebene um. Anders als $nor, das ein Array vollständiger Filterbedingungen entgegennimmt, umschließt $not einen einzelnen Operator oder regulären Ausdruck: { price: { $not: { $gt: 100 } } }.
$not findet auch Dokumente, in denen das Feld nicht vorhanden ist. Oft ist der Operator redundant zu $ne oder $nin, aber besonders nützlich zum Negieren regulärer Ausdrücke: { name: { $not: /^admin/i } } – für Regex-Muster gibt es kein entsprechendes $ne.
// $not with a comparison operator
db.products.find({
price: { $not: { $gt: 100 } }
});
// Matches: price <= 100 AND documents where price field is absent
// $not with a regex - negate a pattern
db.users.find({
username: { $not: /^admin/i }
});
// Users whose username does NOT start with 'admin' (case-insensitive)
// Negating $in
db.items.find({
status: { $not: { $in: ['draft', 'archived'] } }
});$and, $or und $not kombinieren
Logische Operatoren können verschachtelt werden, um beliebig komplexe boolesche Logik auszudrücken. Stellen Sie sich einen Logikbaum vor: Äußere $and-Bedingungen werden auf der obersten Ebene verknüpft, während $or-Teilausdrücke Alternativen innerhalb eines Zweigs ausdrücken.
Komplexe verschachtelte boolesche Abfragen können schwer lesbar sein. Erwägen Sie, sie in benannten JavaScript-Variablen zu speichern oder das Filterobjekt programmgesteuert aus Benutzereingaben aufzubauen, statt es in einem einzigen Objektliteral fünf Ebenen tief zu verschachteln.
// Complex: (premium OR admin) AND (active) AND NOT (suspended)
db.users.find({
$and: [
{ $or: [{ role: 'premium' }, { role: 'admin' }] },
{ active: true },
{ suspended: { $not: { $eq: true } } }
]
});
// Programmatic filter building (cleaner)
const filter = {};
if (roles.length > 0) filter['$or'] = roles.map(r => ({ role: r }));
if (activeOnly) filter.active = true;
db.users.find(filter);Überlegungen zur $or-Performance
$or-Abfragen weisen ein spezifisches Verhalten bei der Indexverwendung auf. MongoDB wertet jeden Zweig von $or unabhängig aus und führt die Ergebnisse zusammen:
- Wenn jeder Zweig einen Index verwenden kann, führt MongoDB eine Indexvereinigung durch – das ist effizient.
- Wenn ein Zweig keinen Index verwenden kann, greift MongoDB für diesen Zweig auf einen Collection-Scan zurück – das kann langsam sein.
Stellen Sie für eine optimale Performance sicher, dass für jeden Zweig von $or ein passender Index vorhanden ist. Wenn sich $or-Bedingungen für dasselbe Feld als $in umschreiben lassen ({ status: { $in: ['a','b'] } }), sollten Sie dies tun – $in ist effizienter als ein zweizweigiges $or für dasselbe Feld.
// Inefficient: $or that prevents index use
db.products.find({
$or: [
{ price: { $lt: 50 } },
{ description: { $regex: 'sale' } } // Regex on unindexed field = COLLSCAN
]
});
// The regex branch causes a full scan for all matched documents
// Better: use $in when possible (same field, multiple values)
db.products.find({ category: { $in: ['A', 'B', 'C'] } });
// Single index lookup is more efficient than 3-branch $orLogische Operatoren in der Aggregationspipeline
In Aggregationspipeline-Stufen wie $match funktionieren dieselben logischen Operatoren genauso wie in find(). Platzieren Sie $match mit Ihren logischen Bedingungen so früh wie möglich in der Pipeline, um die Anzahl der Dokumente zu verringern, die von nachfolgenden Stufen verarbeitet werden.
Innerhalb von Pipeline-Ausdrucksoperatoren (wie $project oder $addFields) haben logische Operatoren eine etwas andere Syntax: { $and: [expr1, expr2] } wird dort als Ausdrucksoperator und nicht als Abfrageoperator verwendet. Der Abfragekontext ($match) und der Ausdruckskontext ($project) verwenden dieselben Operatornamen, aber unterschiedliche Syntaxen.
// $match with logical operators in an aggregation pipeline
db.orders.aggregate([
{
$match: {
$or: [
{ status: 'shipped' },
{ status: 'delivered' }
],
createdAt: { $gte: new Date('2024-01-01') }
}
},
{ $group: { _id: '$customerId', totalOrders: { $sum: 1 } } }
]);Praktisches Muster zum Erstellen von Filtern
In realen Anwendungen werden Abfragefilter häufig dynamisch aus Benutzereingaben erstellt (Suchformulare, API-Abfrageparameter). Bauen Sie das Filterobjekt programmgesteuert auf und fügen Sie Bedingungen nur hinzu, wenn der jeweilige Parameter angegeben wurde. Fügen Sie kein $or: [] mit leeren Arrays hinzu, da dies keine Dokumente finden würde.
Validieren und bereinigen Sie alle vom Benutzer bereitgestellten Werte, bevor Sie sie in eine Abfrage aufnehmen. Übergeben Sie niemals ungeprüfte Benutzerzeichenfolgen direkt an $regex, ohne sie zu maskieren – ein Angreifer könnte ein extrem langsames Regex-Muster einschleusen (ReDoS-Angriff).
function buildProductFilter(params) {
const filter = {};
if (params.categories && params.categories.length > 0) {
filter.category = { $in: params.categories };
}
if (params.minPrice != null) {
filter.price = { ...filter.price, $gte: params.minPrice };
}
if (params.maxPrice != null) {
filter.price = { ...filter.price, $lte: params.maxPrice };
}
if (params.inStockOnly) {
filter.stock = { $gt: 0 };
}
return filter;
}
const results = await db.collection('products')
.find(buildProductFilter(req.query)).toArray();Kurzschlussauswertung in MongoDB
MongoDB wertet Ausdrücke mit logischen Operatoren aus, führt aber NICHT unbedingt wie JavaScript eine Kurzschlussauswertung durch. Der Abfrageplaner kann Bedingungen zur Effizienzsteigerung neu anordnen – beispielsweise eine Bedingung, die einen Index verwendet, vor eine Bedingung verschieben, die keinen Index verwendet, unabhängig von ihrer Reihenfolge im Abfragedokument.
Eine wichtige Folge: In kann der gesamte Abfragevorgang die Collection durchsuchen, wenn der erste Zweig einen vollständigen Collection-Scan verursacht, selbst wenn der zweite Zweig effizient indiziert ist. Deshalb ist es für die Performance so entscheidend, dass jeder Zweig von indiziert ist. Verwenden Sie explain(), um zu überprüfen, ob der Ausführungsplan Ihren Erwartungen entspricht.
// MongoDB may reorder these conditions for efficiency:
db.products.find({
: [
{ category: 'Electronics' }, // If indexed: fast point lookup
{ description: /wireless/i } // Not indexed: slow scan
]
});
// Even though category (indexed) is listed first,
// if MongoDB cannot use index union, it may scan all docs.
// Always verify with .explain('executionStats')Kurze Überprüfung
Testen Sie Ihr Verständnis der Konzepte zu MongoDB und NoSQL-Datenbanken aus dieser Lektion.
Zusammenfassung der Lektion
In dieser Lektion haben Sie gelernt: Das implizite AND ist der Standard, wenn mehrere Felder in einem Filterobjekt aufgelistet werden – ein explizites $and ist nur erforderlich, wenn sich Bedingungen nicht als eindeutige Schlüssel ausdrücken lassen (z. B. zwei $or-Blöcke). $or findet Dokumente, die eine beliebige Bedingung erfüllen, und verwendet eine Indexvereinigung, wenn jeder Zweig indiziert ist. $not kehrt einen einzelnen Operator um und eignet sich besonders zum Negieren von Regex-Mustern, auf die $ne nicht anwendbar ist. Als Nächstes sehen wir uns Elementoperatoren wie $exists und $type an, mit denen sich optionale Felder und Felder mit gemischten Typen verarbeiten lassen.
Lerne JavaScript mit einem KI-Tutor — kostenlos
Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.
- Kurse
- 30
- Lektionen
- 120
Häufig gestellte Fragen
Ist die Lektion „Logische Operatoren: $and, $or, $nor, $not“ kostenlos?
Ja — der vollständige Text von „Logische Operatoren: $and, $or, $nor, $not“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des MongoDB Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der MongoDB Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Logische Operatoren: $and, $or, $nor, $not“?
Kombinieren Sie mehrere Bedingungen mit logischen Operatoren, um komplexe Filterlogik auszudrücken. Du übst MongoDB Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um MongoDB Academy zu starten?
Keine Vorkenntnisse erforderlich. MongoDB Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.
Wie lange dauert die Lektion „Logische Operatoren: $and, $or, $nor, $not“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser MongoDB Academy-Lektion Code schreiben und ausführen?
Ja. Jede MongoDB Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Vergleichsoperatoren: $eq, $gt, $lt, $in
- Logische Operatoren: $and, $or, $nor, $not
- Elementoperatoren und Typprüfungen
- Regex-Abfragen und Mustersuche