Autofullføring og fuzzy-matching
Deltakerne vil konfigurere en autofullføringsanalysator på et felt og skrive fuzzy-spørringer for å håndtere skrivefeil i brukernes søkeinndata.
Autofullføring og fuzzy-matching er en gratis leksjon i MongoDB Academy på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i MongoDB Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i MongoDB Academy inneholder totalt 4 leksjoner.
Hvorfor autofullføring og omtrentlig søk er viktig
Moderne søkeopplevelser krever to viktige funksjoner: autofullføring (forslag til fullføringer mens brukeren skriver) og omtrentlig samsvar (å finne resultater selv når brukeren skriver feil i spørringen). Disse funksjonene forbedrer brukeropplevelsen betydelig – autofullføring reduserer friksjonen i søket ved å lede brukerne mot gyldige spørringer, mens omtrentlig samsvar sikrer at en skrivefeil ikke fører til «ingen resultater funnet». Atlas Search tilbyr begge deler gjennom dedikerte operatorer og analysatorer.
Konfigurere en analysator for autofullføring
Autofullføring krever en spesialkonfigurasjon av feltet i Atlas Search-indeksen. Bruk autocomplete-datatypen i indeksens tilordning for feltet De vil støtte forslag mens brukeren skriver. Dette får Atlas til å indeksere n-grammer og kantn-grammer av feltverdien – delstrenger som samsvarer med delvise inndata. Alternativet tokenization kan være 'edgeGram' (venstreforankrede delstrenger) eller 'nGram' (alle delstrenger), med valgfrie størrelser angitt av minGrams og 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
}
]
}
}
}Kjøre en spørring med autofullføring
Bruk autocomplete-operatoren i et $search-steg for å utføre spørringer med forslag mens brukeren skriver. Angi query (den delen av inndataene som er skrevet så langt) og path (feltet som er indeksert for autofullføring). Send en ny spørring for hvert tegn brukeren skriver, og returner de beste forslagene sortert etter score. Begrens resultatene til 5–10 forslag for å sikre et responsivt brukergrensesnitt.
// 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);
}Tokenisering med edgeGram kontra nGram
edgeGram oppretter delstrenger som er forankret ved starten av hvert ord: «MongoDB» gir «Mo», «Mon», «Mong», «Mongo», «MongoD» og «MongoDB». Dette samsvarer med spørringer som starter med de riktige tegnene, og er et godt standardvalg for navnesøk. nGram oppretter alle delstrenger i et ord, slik at samsvar midt i ordet blir mulig: «ongo» vil også samsvare med «MongoDB». nGram er mer fleksibelt, men gir en mye større indeks og kan returnere mindre presise forslag.
// 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 choiceOmtrentlig samsvar med fuzzy-alternativet
text-operatoren støtter alternativet fuzzy, som aktiverer samsvar basert på redigeringsavstand. Den finner dokumenter der tokenene ligger innenfor et angitt antall tegnredigeringer (innsettinger, slettinger, erstatninger eller ombyttinger) fra spørringens token. Dette gjør søket tolerant for skrivefeil. Parameteren maxEdits styrer toleransen (1 = én skrivefeil tillates, 2 = to skrivefeil tillates).
// 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 }
])Fuzzy-parametere: maxEdits og prefixLength
maxEdits kan være 1 eller 2 (Lucene støtter ikke høyere verdier). Høyere verdier øker treffmengden, men reduserer presisjonen – med maxEdits: 2 kan mange uvedkommende ord samsvare. prefixLength angir hvor mange tegn i starten av hvert spørringstoken som må samsvare nøyaktig før omtrentlig samsvar brukes. En prefikslengde på 2–3 gir en god balanse mellom ytelse og nøyaktighet og hindrer algoritmen i å utføre omtrentlig samsvar mot hvert token i indeksen.
// 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 }Kombinere autofullføring og fuzzy
Autofullføring og omtrentlig samsvar brukes i ulike situasjoner, men kan kombineres i en compound-spørring. autocomplete-operatoren håndterer prefikssamsvar mens brukeren skriver, mens fuzzy-samsvar i en text-operator hjelper når brukeren sender inn en fullstendig, men feilstavet spørring. Et vanlig mønster er å prøve autofullføring først (mens brukeren skriver) og bytte til et fuzzy-tekstsøk når brukeren sender inn spørringen.
// 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();
}
}Tokenrekkefølge i autofullføring
Som standard sammenligner autocomplete-operatoren den delvise spørringen med individuelle token (ord) i feltet. De kan angi tokenOrder: 'sequential' for å kreve at tokenene vises i riktig rekkefølge – nyttig for inndata med flere ord, for eksempel at «node js» foreslår «Node.js Developer Guide». Standardverdien tokenOrder: 'any' returnerer resultater der et hvilket som helst ord starter med prefikset, uavhengig av rekkefølgen.
// 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' }
}
}
])Utsette forespørsler om autofullføring
Autofullføringsspørringer sendes ved hvert tastetrykk, noe som kan overbelaste backend-systemet med raske forespørsler. Implementer alltid debouncing på klientsiden – vent 200–300 ms etter det siste tastetrykket før spørringen sendes. Avbryt også forespørsler som pågår, når en ny forespørsel sendes, for å unngå svar i feil rekkefølge. I React kan De bruke en debounce-hook eller et bibliotek; i en enkel frontend kan De bruke clearTimeout og 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
}Scoring og relevans i autofullføring
Atlas Search returnerer resultater for autofullføring i rekkefølge etter relevansscore. Felt der spørringsprefikset står i begynnelsen av hele feltverdien (i stedet for senere i strengen), får høyere score. De kan påvirke scoringen ytterligere ved å bruke alternativet score til å booste, bruke konstant score eller gradvis redusere scoren for resultater basert på andre faktorer, som popularitet eller aktualitet. Dette sørger for at de mest nyttige forslagene vises først.
// 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 } }
])Beste praksis for minimumslengde på spørringer
Unngå å kjøre autofullføringsspørringer for svært korte inndata (ett tegn), siden de returnerer et overveldende antall irrelevante forslag og er kostbare for Lucene-motoren. Krev en minimumslengde på spørringen på 2–3 tegn før autofullføringsforespørselen sendes. For omtrentlig samsvar bør De på samme måte først aktivere fuzzy etter at brukeren har skrevet minst 3–4 tegn, slik at Lucene har nok kontekst til å beregne redigeringsavstanden på en meningsfull måte. Disse grensene forbedrer både ytelsen og kvaliteten på forslagene.
// 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);
}Kort kontroll
Test forståelsen Deres av konseptene MongoDB & NoSQL Databases fra denne leksjonen.
Oppsummering av leksjonen
I denne leksjonen lærte De at: autofullføring krever datatypen «autocomplete» i indeksens tilordning, med tokenisering (edgeGram eller nGram) for å indeksere delstrenger, autocomplete-operatoren i $search aktiverer prefikssamsvar for forslag mens brukeren skriver, og fuzzy-alternativet i text-operatoren bruker samsvar basert på redigeringsavstand for å håndtere skrivefeil, med konfigurerbare parametere for maxEdits og prefixLength. Deretter skal vi se på fasetter og compound-spørringer for avanserte søkeopplevelser.
Lær deg JavaScript med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 30
- Leksjoner
- 120
Ofte stilte spørsmål
Er leksjonen «Autofullføring og fuzzy-matching» gratis?
Ja – hele teksten i «Autofullføring og fuzzy-matching» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av MongoDB Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i MongoDB Academy inneholder totalt 4 leksjoner.
Hva lærer jeg i «Autofullføring og fuzzy-matching»?
Deltakerne vil konfigurere en autofullføringsanalysator på et felt og skrive fuzzy-spørringer for å håndtere skrivefeil i brukernes søkeinndata. Du øver på MongoDB Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med MongoDB Academy?
Ingen tidligere erfaring er nødvendig. MongoDB Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.
Hvor lang tid tar leksjonen «Autofullføring og fuzzy-matching»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne MongoDB Academy-leksjonen?
Ja. Alle MongoDB Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- Opprette en Atlas Search-indeks
- Skrive $search-spørringer: Tekst, frase og wildcard
- Autofullføring og fuzzy-matching
- Fasetter og sammensatte spørringer