Requêtes avec expressions régulières et recherche de motifs
Vous appliquerez des expressions régulières aux champs texte pour effectuer des recherches flexibles par motif.
Requêtes avec expressions régulières et recherche de motifs est une leçon MongoDB Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage MongoDB Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours MongoDB Academy comprend 4 leçons au total.
Quand utiliser la recherche de motifs
Vous devez parfois rechercher des documents dans lesquels un champ texte contient, commence par ou se termine par un motif donné — sans connaître la valeur exacte. Les filtres d'égalité simples tels que { name: 'Alice' } ne correspondent qu'aux chaînes exactes. Les expressions régulières (regex) permettent une recherche flexible de motifs dans les champs texte de MongoDB.
MongoDB prend en charge les expressions régulières avec l'opérateur $regex ou en transmettant directement un littéral d'expression régulière JavaScript dans un filtre de requête. Les deux approches fonctionnent, avec une syntaxe légèrement différente pour définir des options telles que l'insensibilité à la casse.
Syntaxe de base des expressions régulières dans MongoDB
Il existe deux façons d'utiliser les expressions régulières dans les requêtes MongoDB :
- Littéral d'expression régulière JS :
{ name: /alice/i }— syntaxe concise, les indicateurs se placent après la barre oblique fermante - Opérateur $regex :
{ name: { $regex: 'alice', $options: 'i' } }— plus verbeux, mais requis lorsqu'il est combiné avec d'autres opérateurs
Les deux formes produisent des résultats identiques. Utilisez la syntaxe littérale JS pour les requêtes simples ; utilisez la forme avec l'opérateur $regex lorsque vous devez construire dynamiquement le motif à partir d'une variable chaîne ou le combiner avec d'autres opérateurs sur le même champ.
// 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' } });Options des expressions régulières : i, m, s, x
MongoDB prend en charge quatre indicateurs d'option pour les expressions régulières :
i— Insensible à la casse :/alice/icorrespond à 'Alice', 'ALICE' et 'alice'm— Multiligne :^et$correspondent au début et à la fin de chaque ligne plutôt qu'à ceux de la chaîne entières— Point étendu à toute la chaîne :.correspond à n'importe quel caractère, y compris les sauts de lignex— Étendu : les espaces dans le motif sont ignorés (pour rendre les motifs avec commentaires plus lisibles)
L'indicateur le plus utilisé est i. L'indicateur m est utile pour rechercher dans des champs texte multilignes, comme le contenu d'un blog. Plusieurs indicateurs peuvent être combinés : { $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 bodyAncres : début et fin d'une chaîne
Utilisez les ancres des expressions régulières pour rechercher le début ou la fin d'un champ texte :
^ancre la recherche au début :/^Admin/correspond aux chaînes qui commencent par 'Admin'$ancre la recherche à la fin :/\.pdf$/correspond aux chaînes qui se terminent par '.pdf'
Un point essentiel concernant les performances : une expression régulière préfixée par un accent circonflexe (/^prefix/) CAN utiliser un index B-tree standard sur ce champ — MongoDB peut accéder directement au préfixe dans l'index. Les recherches par préfixe sont ainsi beaucoup plus rapides que les recherches au milieu d'une chaîne. N'utilisez jamais de caractère générique initial (/.*pattern/ ou /pattern/ sans ^) sur une grande collection sans index de texte.
// 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 thisClasses de caractères et quantificateurs
Les expressions régulières fournissent des éléments de motif expressifs :
.— n'importe quel caractère (sauf un saut de ligne, à moins que l'indicateurssoit défini)[abc]— classe de caractères : correspond à a, b ou c[a-z]— plage : n'importe quelle lettre minuscule\d— n'importe quel chiffre (équivalent à[0-9])\w— n'importe quel caractère alphanumérique ou trait de soulignement ([a-zA-Z0-9_])*,+,?— zéro ou plusieurs, un ou plusieurs, zéro ou un{n},{n,m}— exactement n occurrences, ou entre n et m occurrences
// 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' } });Expressions régulières ou index de texte : faites la différence
Les requêtes par expressions régulières et l'opérateur $text de MongoDB ont des objectifs différents et des caractéristiques de performance très différentes :
- Expressions régulières : correspondent à un motif de caractères. Fonctionnent sur tout champ texte, sans index spécial (même si les ancres de préfixe utilisent les index B-tree). Conviennent à la validation de formats, aux recherches par préfixe ou à la recherche de motifs dans de petites collections ou au moyen de requêtes par préfixe indexées.
$text/ index de texte : recherche plein texte par mots-clés, avec segmentation en jetons, radicalisation et filtrage des mots vides. Nécessite un index de texte. Est beaucoup plus rapide pour rechercher des mots-clés dans de grands champs texte (articles, descriptions, commentaires).
N'utilisez jamais /.*keyword.*/i sur une grande collection non indexée : cela effectue un parcours complet et peut être lent.
// 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 : le risque de sécurité
ReDoS (Regular Expression Denial of Service) est une attaque au cours de laquelle un utilisateur malveillant crée une chaîne d'entrée qui force une expression régulière mal écrite à prendre un temps exponentiel pour être évaluée. Si vous transmettez directement une entrée utilisateur à une expression régulière sans l'échapper, un attaquant peut bloquer votre requête de base de données.
Échappez toujours les entrées utilisateur avant de les utiliser dans une expression régulière, en remplaçant tous les caractères spéciaux des expressions régulières (. * + ? ^ $ { } ( ) [ ] | \ ) par leurs équivalents échappés. De nombreuses bibliothèques (comme escape-string-regexp dans Node.js) le font automatiquement. De plus, préférez $text aux expressions régulières brutes pour les entrées de recherche destinées aux utilisateurs.
// 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 } });Expressions régulières sur les champs tableau
Lorsque vous appliquez une expression régulière à un champ tableau, MongoDB vérifie si au moins un élément du tableau correspond au motif — avec la même sémantique de contenance que les requêtes d'égalité sur les tableaux. Vous pouvez ainsi rechercher dans des tableaux d'étiquettes, de catégories ou dans n'importe quel tableau de chaînes, sans opérateur spécial.
Par exemple, un document contenant tags: ['node.js', 'mongodb', 'backend'] serait renvoyé par { tags: /^mongo/ }, car 'mongodb' commence par 'mongo'. L'expression régulière est appliquée séparément à chaque élément.
// 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 });Exemple pratique de recherche
Une fonctionnalité de recherche typique pour un site de commerce en ligne combine les expressions régulières avec d'autres filtres afin de proposer une recherche de produits contextuelle et insensible à la casse. La requête recherche les noms de produits qui contiennent le terme recherché n'importe où dans la chaîne, tout en filtrant par catégorie et par disponibilité en stock.
Pour les petits catalogues (moins de 50 000 produits), la recherche par expression régulière est acceptable. Pour les catalogues plus importants ou la recherche dans les descriptions complètes, Atlas Search (fondé sur Lucene) offre une pertinence, une radicalisation et des performances supérieures.
// 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);
});Résumé des performances des expressions régulières
Règles essentielles pour les performances des expressions régulières dans MongoDB :
- Préfixe avec
^(/^prefix/) : peut utiliser un index B-tree. Meilleures performances pour les expressions régulières. - Préfixe sensible à la casse (
/^prefix/) : exploite pleinement l'ordre de l'index. - Préfixe insensible à la casse (
/^prefix/i) : utilise partiellement l'index, tout en restant beaucoup plus rapide qu'une recherche sans ancre. - Contenu sans ancre (
/pattern/) : parcours complet de la collection — utilisez plutôt un index de texte. - Suffixe (
/pattern$/) : parcours complet de la collection ou index de texte.
En cas de doute, vérifiez avec explain('executionStats') et recherchez IXSCAN ou 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!)Tester les motifs d'expressions régulières avant le déploiement
Avant d'exécuter une requête par expression régulière sur une collection de production, testez le motif sur des documents d'exemple afin de vérifier qu'il correspond à ce que vous souhaitez et qu'il ne correspond pas à ce que vous ne souhaitez pas. L'interpréteur de commandes MongoDB vous permet d'effectuer rapidement un test avec un petit limit(), et String.prototype.test() de JavaScript ou les littéraux d'expressions régulières vous permettent de valider les motifs dans Node.js avant de les intégrer aux requêtes.
Vérifiez également les performances avec explain() : une expression régulière qui nécessite un parcours complet de la collection doit être convertie en requête textuelle, ou la taille de la collection doit être prise en compte. Pour les nouvelles collections, concevez votre structure en tenant compte des besoins de recherche : ajoutez les index de texte dès le départ plutôt que de les intégrer ultérieurement.
// 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');Vérification rapide
Vérifiez votre compréhension des concepts MongoDB et des bases de données NoSQL présentés dans cette leçon.
Récapitulatif de la leçon
Dans cette leçon, vous avez appris que les requêtes par expressions régulières utilisent /pattern/flags ou l'opérateur $regex pour rechercher des motifs flexibles dans les chaînes — l'indicateur le plus important est i pour l'insensibilité à la casse —, que les expressions régulières ancrées sur un préfixe (/^prefix/) peuvent utiliser des index B-tree pour des recherches efficaces, tandis que les motifs au milieu d'une chaîne nécessitent des parcours complets, et qu'il faut toujours échapper les entrées utilisateur avant de les insérer dans une expression régulière afin d'empêcher les attaques ReDoS — ou, mieux encore, utiliser l'opérateur $text avec un index de texte pour les recherches destinées aux utilisateurs. Ensuite, nous passerons à la mise à jour des documents avec $set, $unset et d'autres opérateurs de mise à jour.
Apprends JavaScript avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 30
- Leçons
- 120
Questions Fréquemment Posées
La leçon « Requêtes avec expressions régulières et recherche de motifs » est-elle gratuite ?
Oui — le texte complet de « Requêtes avec expressions régulières et recherche de motifs » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours MongoDB Academy, passe à CoddyKit PRO. Le cours MongoDB Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Requêtes avec expressions régulières et recherche de motifs » ?
Vous appliquerez des expressions régulières aux champs texte pour effectuer des recherches flexibles par motif. Tu pratiques MongoDB Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer MongoDB Academy ?
Aucune expérience préalable n'est requise. MongoDB Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.
Combien de temps prend la leçon « Requêtes avec expressions régulières et recherche de motifs » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon MongoDB Academy ?
Oui. Chaque leçon MongoDB Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Opérateurs de comparaison : $eq, $gt, $lt, $in
- Opérateurs logiques : $and, $or, $nor, $not
- Opérateurs d’élément et vérifications de type
- Requêtes avec expressions régulières et recherche de motifs