Regex-Abfragen und Mustersuche
Wenden Sie reguläre Ausdrücke auf String-Felder an, um flexibel nach Textmustern zu suchen.
Regex-Abfragen und Mustersuche ist eine kostenlose MongoDB Academy-Lektion auf CoddyKit. Dies ist Lektion 4 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.
Wann Sie Mustervergleiche benötigen
Manchmal müssen Sie nach Dokumenten suchen, bei denen ein Zeichenfolgenfeld ein bestimmtes Muster enthält, mit ihm beginnt oder mit ihm endet – den exakten Wert kennen Sie jedoch nicht. Einfache Gleichheitsfilter wie { name: 'Alice' } finden nur exakt übereinstimmende Zeichenfolgen. Reguläre Ausdrücke (Regex) ermöglichen flexible Mustervergleiche für Zeichenfolgenfelder in MongoDB.
MongoDB unterstützt Regex über den Operator $regex oder indem Sie ein JavaScript-Regex-Literal direkt in einem Abfragefilter übergeben. Beide Ansätze funktionieren, unterscheiden sich jedoch leicht in der Syntax zum Festlegen von Optionen wie der Groß- und Kleinschreibung.
Grundlegende Regex-Syntax in MongoDB
Es gibt zwei Möglichkeiten, Regex in MongoDB-Abfragen zu verwenden:
- JS-Regex-Literal:
{ name: /alice/i }– kompakt, die Flags stehen nach dem schließenden Schrägstrich - $regex-Operator:
{ name: { $regex: 'alice', $options: 'i' } }– ausführlicher, aber erforderlich, wenn Sie ihn mit anderen Operatoren kombinieren
Beide Formen liefern identische Ergebnisse. Verwenden Sie die Literal-Syntax für einfache Abfragen und die Form mit dem $regex-Operator, wenn Sie das Muster dynamisch aus einer String-Variable erstellen oder mit anderen Operatoren für dasselbe Feld kombinieren müssen.
// JS regex literal - concise
db.users.find({ name: /alice/i });
// 'i' flag = case-insensitive
// $regex operator - equivalent
db.users.find({ name: { $regex: 'alice', $options: 'i' } });
// Dynamic pattern from variable:
const searchTerm = req.query.name;
const escapedTerm = searchTerm.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // Escape special chars
db.users.find({ name: { $regex: escapedTerm, $options: 'i' } });Regex-Optionen: i, m, s, x
MongoDB unterstützt vier Regex-Flags:
i– Groß- und Kleinschreibung wird ignoriert:/alice/ifindet „Alice“, „ALICE“ und „alice“m– Mehrzeilig:^und$beziehen sich auf den Anfang bzw. das Ende jeder Zeile statt auf die gesamte Zeichenfolges– Dot-all:.findet jedes Zeichen einschließlich Zeilenumbrüchenx– Erweitert: Leerzeichen im Muster werden ignoriert (für besser lesbare Muster mit Kommentaren)
Das am häufigsten verwendete Flag ist i. Das Flag m eignet sich für die Suche in mehrzeiligen Textfeldern wie Bloginhalten. Mehrere Flags können kombiniert werden: { $options: 'im' }.
// Case-insensitive search for 'javascript'
db.courses.find({ title: { $regex: 'javascript', $options: 'i' } });
// Matches: 'JavaScript', 'JAVASCRIPT', 'javascript', 'JavaScript Tutorial'
// Multiline match: ^ anchors to start of each line
db.articles.find({ content: { $regex: '^Introduction', $options: 'm' } });
// Matches articles where any line starts with 'Introduction'
// Combined flags
db.posts.find({ body: { $regex: 'mongodb', $options: 'si' } });
// Case-insensitive + dot matches newlines in bodyAnker: Anfang und Ende von Zeichenfolgen
Verwenden Sie Regex-Anker, um den Anfang oder das Ende eines Zeichenfolgenfelds zu finden:
^verankert das Muster am Anfang:/^Admin/findet Zeichenfolgen, die mit „Admin“ beginnen$verankert das Muster am Ende:/\.pdf$/findet Zeichenfolgen, die mit „.pdf“ enden
Ein wichtiger Aspekt der Performance: Ein Präfix-Regex mit Caret (/^prefix/) KANN einen regulären B-Tree-Index für dieses Feld verwenden – MongoDB kann im Index direkt zum Präfix springen. Dadurch sind Präfixsuchen deutlich schneller als Suchen innerhalb einer Zeichenfolge. Verwenden Sie bei einer großen Collection niemals einen führenden Wildcard-Ausdruck (/.*pattern/ oder /pattern/ ohne ^), wenn kein Textindex vorhanden ist.
// Prefix match - CAN use index (very efficient)
db.users.find({ username: /^admin/i });
// Matches: 'admin', 'administrator', 'Admin123'
// Uses the index on username (if it exists)
// Suffix match - CANNOT use regular index (slower)
db.files.find({ filename: /\.pdf$/i });
// Matches: 'report.pdf', 'invoice.PDF'
// Must scan all documents - add text index if used frequently
// Mid-string - CANNOT use index
db.products.find({ description: /wireless/i });
// Must scan all documents - use $text index for thisZeichenklassen und Quantifizierer
Regex stellt ausdrucksstarke Grundelemente für Muster bereit:
.– beliebiges Zeichen (außer Zeilenumbruch, sofern nicht dass-Flag gesetzt ist)[abc]– Zeichenklasse: findet a, b oder c[a-z]– Bereich: beliebiger Kleinbuchstabe\d– beliebige Ziffer (entspricht[0-9])\w– beliebiges Wortzeichen ([a-zA-Z0-9_])*,+,?– null oder mehr, mindestens eines oder null bzw. eines{n},{n,m}– genau n bzw. zwischen n und m Vorkommen
// Phone number pattern: +1-XXX-XXX-XXXX or similar
db.users.find({ phone: /^\+?\d{1,3}[-. ]?\(?\d{3}\)?[-. ]?\d{3}[-. ]?\d{4}$/ });
// 6-character alphanumeric codes
db.coupons.find({ code: /^[A-Z0-9]{6}$/ });
// Matches: 'SALE99', 'DISC25', 'FREE01'
// Email basic validation
db.users.find({ email: { $regex: '^[\\w.]+@[\\w.]+\\.[a-z]{2,}$', $options: 'i' } });Regex und Textindex: Kennen Sie den Unterschied
Regex-Abfragen und der MongoDB-Operator $text dienen unterschiedlichen Zwecken und weisen sehr unterschiedliche Performance-Eigenschaften auf:
- Regex: vergleicht nach Zeichenmustern. Funktioniert mit jedem Zeichenfolgenfeld und benötigt keinen speziellen Index (Präfix-Anker können jedoch B-Tree-Indizes verwenden). Geeignet für Formatvalidierung, Präfixsuchen oder Mustervergleiche in kleinen Collections bzw. indizierten Präfixabfragen.
- $text / Textindex: Volltextsuche nach Schlüsselwörtern mit Tokenisierung, Stemming und Filterung von Stoppwörtern. Erfordert einen Textindex. Bei der Suche nach Schlüsselwörtern in großen Textfeldern (Artikeln, Beschreibungen, Kommentaren) deutlich schneller.
Verwenden Sie niemals /.*keyword.*/i für eine große, nicht indizierte Collection – dies führt zu einem vollständigen Scan und kann langsam sein.
// Use REGEX for: format matching, prefix searches on indexed field
db.orders.find({ orderNumber: /^ORD-2024/ }); // Prefix - can use index
// Use $text for: keyword search in content fields
// First: create a text index
db.articles.createIndex({ content: 'text', title: 'text' });
// Then: full-text search
db.articles.find({ $text: { $search: 'mongodb performance' } });
// Much faster than /mongodb.*performance/i on large collectionsReDoS: Das Sicherheitsrisiko
ReDoS (Regular Expression Denial of Service) ist ein Angriff, bei dem ein böswilliger Benutzer eine Eingabezeichenfolge erstellt, die dazu führt, dass ein fehlerhaft formulierter Regex für die Auswertung exponentiell lange benötigt. Wenn Sie Benutzereingaben ohne Escaping direkt in einem Regex verwenden, kann ein Angreifer Ihre Datenbankabfrage blockieren.
Escapen Sie Benutzereingaben immer, bevor Sie sie in einem Regex verwenden, indem Sie alle speziellen Regex-Zeichen (. * + ? ^ $ { } ( ) [ ] | \ ) durch ihre maskierten Entsprechungen ersetzen. Viele Bibliotheken, etwa escape-string-regexp in Node.js, erledigen dies automatisch. Verwenden Sie für Suchfelder, die Benutzern zur Verfügung stehen, außerdem vorzugsweise $text statt eines direkten Regex.
// DANGEROUS: raw user input in regex (ReDoS risk)
const input = req.query.search; // User controls this
db.products.find({ name: { $regex: input } }); // NEVER DO THIS
// SAFE: escape user input before using in regex
function escapeRegex(str) {
return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
}
const safeInput = escapeRegex(req.query.search);
db.products.find({ name: { $regex: safeInput, $options: 'i' } });
// BETTER: Use $text for user-facing search
db.products.find({ $text: { $search: req.query.search } });Regex für Array-Felder
Wenn Sie einen Regex auf ein Array-Feld anwenden, prüft MongoDB, ob irgendein Element des Arrays dem Muster entspricht – mit derselben Enthaltungssemantik wie bei Gleichheitsabfragen für Arrays. So können Sie Arrays mit Tags, Kategorien oder beliebigen Zeichenfolgen durchsuchen, ohne einen speziellen Operator zu benötigen.
Beispielsweise würde ein Dokument mit tags: ['node.js', 'mongodb', 'backend'] von { tags: /^mongo/ } zurückgegeben, weil „mongodb“ mit „mongo“ beginnt. Der Regex wird unabhängig auf jedes Element angewendet.
// Document: { tags: ['node.js', 'mongodb', 'backend-dev'] }
// Find products where any tag starts with 'mongo'
db.products.find({ tags: /^mongo/i });
// Returns the document (tags contains 'mongodb')
// Find articles where any category contains 'tech'
db.articles.find({ categories: /tech/i });
// Matches: categories containing 'technology', 'tech-news', 'fintech'
// Index on array field improves regex prefix searches
db.articles.createIndex({ categories: 1 });Praktisches Suchbeispiel
Eine typische E-Commerce-Suche kombiniert Regex mit anderen Filtern, um eine kontextbezogene, die Groß- und Kleinschreibung ignorierende Produktsuche bereitzustellen. Die Abfrage findet Produktnamen, die den Suchbegriff an beliebiger Stelle enthalten, und filtert zusätzlich nach Kategorie und Lagerbestand.
Für kleine Kataloge (unter 50.000 Produkte) ist die Regex-Suche akzeptabel. Für größere Kataloge oder die Suche in vollständigen Beschreibungen bietet Atlas Search (auf Lucene-Basis) eine bessere Relevanzbewertung, Stemming und Performance.
// Search endpoint: GET /products?q=wireless&category=Electronics
app.get('/products', async (req, res) => {
const filter = { stock: { $gt: 0 } };
if (req.query.q) {
const escaped = req.query.q.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
filter.name = { $regex: escaped, $options: 'i' };
}
if (req.query.category) {
filter.category = req.query.category;
}
const products = await db.collection('products')
.find(filter)
.project({ name: 1, price: 1, _id: 1 })
.limit(50)
.toArray();
res.json(products);
});Zusammenfassung der Regex-Performance
Wichtige Regeln für die Regex-Performance in MongoDB:
- Präfix mit
^(/^prefix/): Kann einen B-Tree-Index verwenden. Beste Performance bei Regex. - Präfix mit Beachtung der Groß- und Kleinschreibung (
/^prefix/): Nutzt die Indexsortierung vollständig. - Präfix ohne Beachtung der Groß- und Kleinschreibung (
/^prefix/i): Verwendet den Index teilweise, ist aber dennoch deutlich schneller als eine Abfrage ohne Anker. - Enthaltensein ohne Anker (
/pattern/): Vollständiger Collection-Scan – verwenden Sie stattdessen einen Textindex. - Suffix (
/pattern$/): Vollständiger Collection-Scan oder Textindex.
Testen Sie im Zweifelsfall mit explain('executionStats') und achten Sie auf IXSCAN im Vergleich zu COLLSCAN.
// Check if regex query uses an index
db.users.find({ username: /^alice/i })
.explain('executionStats');
// winningPlan.stage should be 'IXSCAN' if username is indexed
// Compare index scan vs collection scan:
// /^alice/ on indexed field: totalDocsExamined ~= nReturned (efficient)
// /alice/ on any field: totalDocsExamined = all documents (slow!)Regex-Muster vor der Bereitstellung testen
Bevor Sie eine Regex-Abfrage für eine Produktions-Collection ausführen, testen Sie das Muster mit Beispieldokumenten. So stellen Sie sicher, dass es wie beabsichtigt passende und nicht passende Dokumente findet. Mit einer kleinen limit()-Zahl können Sie dies in der MongoDB-Shell schnell prüfen. Mit JavaScripts String.prototype.test() oder Regex-Literalen können Sie Muster in Node.js validieren, bevor Sie sie in Abfragen einbetten.
Prüfen Sie außerdem die Performance mit explain(): Ein Regex, der einen vollständigen Collection-Scan erfordert, sollte in eine Textabfrage umgewandelt werden, oder Sie sollten die Größe der Collection berücksichtigen. Planen Sie bei neuen Collections die Suchanforderungen von Anfang an ein – fügen Sie Textindizes direkt hinzu, statt sie nachträglich einzurichten.
// Step 1: Test regex in Node.js before using in query
const pattern = /^wireless/i;
const testStrings = ['Wireless Headphones', 'wireless mouse', 'Wired Keyboard'];
testStrings.forEach(s => console.log(s, '=>', pattern.test(s)));
// 'Wireless Headphones' => true
// 'wireless mouse' => true
// 'Wired Keyboard' => false
// Step 2: Test on production with limit
db.products.find({ name: /^wireless/i }).limit(5);
// Step 3: Check performance
db.products.find({ name: /^wireless/i }).explain('executionStats');Schnelltest
Testen Sie Ihr Verständnis der Konzepte zu MongoDB & NoSQL-Datenbanken aus dieser Lektion.
Zusammenfassung der Lektion
In dieser Lektion haben Sie Folgendes gelernt: Regex-Abfragen verwenden /pattern/flags oder den $regex-Operator für flexible Mustervergleiche von Zeichenfolgen – das wichtigste Flag ist i für die Unterscheidung von Groß- und Kleinschreibung. Regexe mit Präfixanker (/^prefix/) können B-Tree-Indizes für effiziente Suchen verwenden, während Muster innerhalb einer Zeichenfolge vollständige Scans erfordern. Escapen Sie Benutzereingaben immer, bevor Sie sie in einen Regex einsetzen, um ReDoS-Angriffe zu verhindern – oder verwenden Sie für die Suche durch Benutzer besser den Operator $text mit einem Textindex. Als Nächstes geht es um das Aktualisieren von Dokumenten mit $set, $unset und anderen Update-Operatoren.
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 „Regex-Abfragen und Mustersuche“ kostenlos?
Ja — der vollständige Text von „Regex-Abfragen und Mustersuche“ 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 „Regex-Abfragen und Mustersuche“?
Wenden Sie reguläre Ausdrücke auf String-Felder an, um flexibel nach Textmustern zu suchen. 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 4 von 4.
Wie lange dauert die Lektion „Regex-Abfragen und Mustersuche“?
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