Saisie semi-automatique et correspondance approximative
Les apprenants configureront un analyseur de saisie semi-automatique sur un champ et écriront des requêtes approximatives pour gérer les fautes de frappe dans les entrées de recherche des utilisateurs.
Saisie semi-automatique et correspondance approximative est une leçon MongoDB Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.
Pourquoi la saisie prédictive et la recherche approximative sont importantes
Les expériences de recherche modernes nécessitent deux fonctionnalités essentielles : la saisie prédictive (proposer des complétions au fur et à mesure que l’utilisateur saisit du texte) et la correspondance approximative (trouver des résultats même lorsque l’utilisateur fait une faute dans sa requête). Ces fonctionnalités améliorent considérablement l’expérience utilisateur : la saisie prédictive facilite la recherche en orientant les utilisateurs vers des requêtes valides, tandis que la correspondance approximative évite qu’une faute de frappe ne produise le message « aucun résultat trouvé ». Atlas Search fournit ces deux fonctionnalités grâce à des opérateurs et des analyseurs dédiés.
Configurer un analyseur de saisie prédictive
La saisie prédictive nécessite une configuration spéciale du champ dans l’index Atlas Search. Utilisez le type de données autocomplete dans le mappage de l’index pour le champ auquel vous souhaitez ajouter la saisie au fur et à mesure. Atlas indexe ainsi les n-grammes et les n-grammes en bordure de la valeur du champ, c’est-à-dire des sous-chaînes correspondant aux saisies partielles. L’option tokenization peut être 'edgeGram' (sous-chaînes ancrées à gauche) ou 'nGram' (toutes les sous-chaînes), avec les tailles facultatives minGrams et maxGrams.
// Atlas Search index definition with autocomplete field
{
'mappings': {
'dynamic': false,
'fields': {
'name': [
{
'type': 'string', // for regular text search
'analyzer': 'lucene.standard'
},
{
'type': 'autocomplete', // for type-ahead queries
'tokenization': 'edgeGram', // 'mongod' -> 'm', 'mo', 'mon', 'mong', 'mongo', 'mongod'
'minGrams': 2,
'maxGrams': 10
}
]
}
}
}Exécuter une requête de saisie prédictive
Utilisez l’opérateur autocomplete dans une étape $search pour effectuer des requêtes avec complétion au fur et à mesure de la saisie. Spécifiez la query (la saisie partielle déjà entrée) et le path (le champ indexé pour la saisie prédictive). À chaque caractère saisi, envoyez une nouvelle requête et renvoyez les meilleures suggestions, triées par score. Limitez les résultats à 5 à 10 suggestions pour garantir une interface réactive.
// As user types 'mon', suggest matching product names
async function getAutocompleteSuggestions(partialQuery) {
const results = await db.collection('products').aggregate([
{
$search: {
autocomplete: {
query: partialQuery, // e.g., 'mon' -> suggests 'Monitor', 'MongoDB Atlas', etc.
path: 'name'
}
}
},
{ $limit: 8 },
{ $project: { name: 1, _id: 0 } }
]).toArray();
return results.map(r => r.name);
}Tokenisation edgeGram ou nGram
edgeGram crée des sous-chaînes ancrées au début de chaque mot : « MongoDB » produit « Mo », « Mon », « Mong », « Mongo », « MongoD » et « MongoDB ». Cela correspond aux requêtes qui commencent par les bons caractères, ce qui en fait une bonne valeur par défaut pour la recherche de noms. nGram crée toutes les sous-chaînes d’un mot, ce qui permet la correspondance au milieu d’un mot : « ongo » correspondrait également à « MongoDB ». nGram est plus flexible, mais produit un index beaucoup plus volumineux et peut renvoyer des suggestions moins précises.
// edgeGram: 'Python' generates:
// 'Py', 'Pyt', 'Pyth', 'Pytho', 'Python'
// -> matches queries starting with 'Py', 'Pyt', etc.
// nGram: 'Python' generates:
// 'Py', 'yt', 'th', 'ho', 'on', 'Pyt', 'yth', 'tho', ... etc.
// -> matches mid-word queries like 'ytho'
// For product name autocomplete, edgeGram is almost always the right choiceCorrespondance approximative avec l’option fuzzy
L’opérateur text prend en charge une option fuzzy qui active la correspondance fondée sur la distance d’édition. Il recherche les documents dont les tokens se trouvent à un nombre donné de modifications de caractères (insertions, suppressions, substitutions ou transpositions) des tokens de la requête. Votre recherche tolère ainsi les fautes de frappe. Le paramètre maxEdits contrôle cette tolérance (1 = une faute autorisée, 2 = deux fautes).
// Fuzzy search: 'Monggodb' matches 'MongoDB' (1 extra 'g')
db.tutorials.aggregate([
{
$search: {
text: {
query: 'Monggodb aggregaton', // two typos
path: 'title',
fuzzy: {
maxEdits: 1, // allow 1 edit per token
prefixLength: 3 // first 3 chars must match exactly
}
}
}
},
{ $limit: 10 }
])Paramètres de correspondance approximative : maxEdits et prefixLength
maxEdits peut être égal à 1 ou 2 (Lucene ne prend pas en charge les valeurs supérieures). Des valeurs plus élevées augmentent le rappel, mais réduisent la précision : avec maxEdits: 2, de nombreux mots sans rapport peuvent correspondre. prefixLength indique combien de caractères au début de chaque token de la requête doivent correspondre exactement avant l’application de la correspondance approximative. Une longueur de préfixe de 2 à 3 offre un bon équilibre entre performances et précision, en évitant que l’algorithme n’effectue une correspondance approximative avec chaque token de l’index.
// Conservative fuzzy: only 1 edit, first 3 chars must be exact
// Good for search boxes where users make occasional typos
fuzzy: { maxEdits: 1, prefixLength: 3 }
// Aggressive fuzzy: 2 edits, no prefix requirement
// Useful for voice-to-text or low-quality input
fuzzy: { maxEdits: 2, prefixLength: 0 }
// Balanced (recommended default):
fuzzy: { maxEdits: 1, prefixLength: 2, maxExpansions: 50 }Combiner la saisie prédictive et la correspondance approximative
La saisie prédictive et la correspondance approximative répondent à des besoins différents, mais peuvent être combinées dans une requête compound. L’opérateur autocomplete gère la correspondance de préfixes pendant la saisie, tandis que la correspondance approximative dans un opérateur text aide lorsque les utilisateurs envoient une requête complète comportant une faute. Une méthode courante consiste à essayer d’abord la saisie prédictive (pendant la saisie), puis à passer à une recherche textuelle approximative lorsque l’utilisateur envoie sa requête.
// Hybrid: autocomplete for prefix + fuzzy for full query
async function search(query, isTyping) {
if (isTyping) {
// During typing: use autocomplete
return db.collection('products').aggregate([
{ $search: { autocomplete: { query, path: 'name' } } },
{ $limit: 6 },
{ $project: { name: 1 } }
]).toArray();
} else {
// On submit: use fuzzy text search
return db.collection('products').aggregate([
{ $search: { text: { query, path: ['name', 'description'], fuzzy: { maxEdits: 1 } } } },
{ $limit: 20 },
{ $project: { name: 1, price: 1, score: { $meta: 'searchScore' } } }
]).toArray();
}
}Ordre des tokens dans la saisie prédictive
Par défaut, l’opérateur autocomplete compare la requête partielle à des tokens individuels (des mots) du champ. Vous pouvez définir tokenOrder: 'sequential' pour exiger que les tokens apparaissent dans l’ordre, ce qui est utile pour les saisies de plusieurs mots telles que « node js », qui peut suggérer « Node.js Developer Guide ». La valeur par défaut tokenOrder: 'any' renvoie les résultats dont l’un des mots commence par le préfixe, quel que soit l’ordre.
// Sequential token order: 'node js' must match 'Node.js' in order
db.courses.aggregate([
{
$search: {
autocomplete: {
query: 'node js',
path: 'title',
tokenOrder: 'sequential' // words must appear in this order
}
}
},
{ $limit: 5 }
])
// Any order: 'js node' would also match 'Node.js'
db.courses.aggregate([
{
$search: {
autocomplete: { query: 'js node', path: 'title', tokenOrder: 'any' }
}
}
])Limiter les requêtes de saisie prédictive
Les requêtes de saisie prédictive sont lancées à chaque frappe, ce qui peut submerger votre serveur principal de requêtes rapides. Implémentez toujours une temporisation groupée côté client : attendez 200 à 300 ms après la dernière frappe avant d’envoyer la requête. Annulez également les requêtes en cours lorsqu’une nouvelle requête est lancée, afin d’éviter les réponses dans le désordre. Dans React, utilisez un crochet ou une bibliothèque de temporisation ; dans une interface simple, utilisez clearTimeout et setTimeout.
// Simple debounce in JavaScript
let debounceTimer;
function onSearchInput(event) {
const query = event.target.value;
clearTimeout(debounceTimer);
debounceTimer = setTimeout(async () => {
if (query.length < 2) return; // minimum length check
const suggestions = await fetch('/api/autocomplete?q=' + encodeURIComponent(query));
renderSuggestions(await suggestions.json());
}, 250); // 250ms debounce
}Score et pertinence dans la saisie prédictive
Atlas Search renvoie les résultats de saisie prédictive dans l’ordre de leur score de pertinence. Les champs dont le préfixe de la requête se trouve au début de la valeur complète du champ, plutôt que plus loin dans la chaîne, reçoivent des scores plus élevés. Vous pouvez également influencer le score à l’aide de l’option score pour augmenter le score, utiliser un score constant ou appliquer une décroissance selon d’autres facteurs, comme la popularité ou la récence. Les suggestions les plus utiles apparaissent ainsi en premier.
// Boost products with higher view counts in autocomplete results
db.products.aggregate([
{
$search: {
autocomplete: {
query: 'wire',
path: 'name',
score: {
boost: {
path: 'viewCount', // boost by view count field
modifier: 'log1p' // log1p smoothing prevents extreme boosts
}
}
}
}
},
{ $limit: 8 },
{ $project: { name: 1, viewCount: 1 } }
])Bonne pratique : longueur minimale de la requête
Évitez d’exécuter des requêtes de saisie prédictive sur des saisies très courtes (1 caractère), car elles renvoient un nombre excessif de suggestions peu pertinentes et sont coûteuses pour le moteur Lucene. Imposez une longueur minimale de requête de 2 à 3 caractères avant de lancer la requête de saisie prédictive. De même, pour la correspondance approximative, activez-la uniquement après la saisie d’au moins 3 à 4 caractères, afin de fournir à Lucene suffisamment de contexte pour calculer une distance d’édition pertinente. Ces limites améliorent à la fois les performances et la qualité des suggestions.
// Client-side minimum length enforcement
async function handleSearchInput(query) {
if (query.length < 2) {
clearSuggestions(); // don't search on 0 or 1 char
return;
}
// Autocomplete: good from 2 chars
if (query.length <= 4) {
return getAutocompleteSuggestions(query);
}
// Fuzzy search: enable after 4 chars for better precision
return getFuzzySearchResults(query);
}Vérification rapide
Vérifiez votre compréhension des concepts de MongoDB et des bases de données NoSQL abordés dans cette leçon.
Récapitulatif de la leçon
Dans cette leçon, vous avez appris que la saisie prédictive nécessite un type de données « autocomplete » dans le mappage de l’index, avec une tokenisation (edgeGram ou nGram) pour indexer les sous-chaînes, que l’opérateur autocomplete dans $search permet la correspondance de préfixes pour les suggestions au fur et à mesure de la saisie, et que l’option fuzzy de l’opérateur text utilise la distance d’édition pour gérer les fautes de frappe, avec les paramètres configurables maxEdits et prefixLength. Nous allons maintenant découvrir les facettes et les requêtes compound pour créer des expériences de recherche sophistiquées.
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 « Saisie semi-automatique et correspondance approximative » est-elle gratuite ?
Oui — le texte complet de « Saisie semi-automatique et correspondance approximative » 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 « Saisie semi-automatique et correspondance approximative » ?
Les apprenants configureront un analyseur de saisie semi-automatique sur un champ et écriront des requêtes approximatives pour gérer les fautes de frappe dans les entrées de recherche des utilisateur… 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 3 sur 4.
Combien de temps prend la leçon « Saisie semi-automatique et correspondance approximative » ?
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
- Créer un index Atlas Search
- Écrire des requêtes $search : texte, expression et générique
- Saisie semi-automatique et correspondance approximative
- Facettes et requêtes composées