MongoDB Academy · Lektion

Sortering efter tekstscore med $meta

De lærende vil projicere og sortere efter textScore for at placere de mest relevante dokumenter øverst i resultaterne.

Lektion 3 af 413 trin

Sortering efter tekstscore med $meta er en gratis MongoDB Academy-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i MongoDB Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. MongoDB Academy-kurset indeholder 4 lektioner i alt.

Hvad er textScore?

Når en $text-forespørgsel køres, beregner MongoDB en relevansscore for hvert matchende dokument, som kaldes textScore. Scoren afspejler, hvor godt dokumentet matcher søgeordene: flere forekomster af søgeordene, match i felter med højere vægt og match af sjældnere tokens øger alle scoren. Som standard sorteres resultaterne ikke efter score; du skal udtrykkeligt anmode om sorteringen.

Projektion af textScore med $meta

Hvis du vil inkludere relevansscoren i dine resultater, skal du tilføje et projektionsfelt med { $meta: 'textScore' }. Du kan kalde feltet hvad som helst (konventionelt score). Udtrykket $meta læser metadata, der beregnes under udførelsen af forespørgslen – textScore er den eneste metadataværdi, der aktuelt understøttes i denne sammenhæng.

db.articles.find(
  { $text: { $search: 'mongodb performance' } },
  {
    title: 1,
    score: { $meta: 'textScore' }  // project the relevance score
  }
);

Sortering efter textScore

Hvis du vil sortere resultater efter relevans, skal du sende { score: { $meta: 'textScore' } } til .sort(). MongoDB sorterer som standard i faldende rækkefølge for textScore (højeste relevans først). Du skal projicere scorefeltet i den samme forespørgsel, når du sorterer efter det – hvis du udelader projektionen, sorterer MongoDB stadig korrekt, men returnerer ikke scoreværdien til klienten.

db.articles
  .find(
    { $text: { $search: 'mongodb performance index' } },
    { title: 1, score: { $meta: 'textScore' } }
  )
  .sort({ score: { $meta: 'textScore' } });
// Results ordered: most relevant first

Sådan beregnes textScore

MongoDB's textScore er baseret på en variant af logikken bag TF-IDF (Term Frequency – Inverse Document Frequency). Termfrekvens: Et dokument, hvor søgeordet forekommer 10 gange, får en højere score end et dokument, hvor det forekommer én gang. Feltvægte: Match i et felt med vægten 10 får en 10 gange højere score end match i et felt med vægten 1. Indekstæthed: Sjældnere ord, der forekommer i færre dokumenter, bidrager mere til scoren end meget almindelige ord.

// Index with weights: title matches count more
db.articles.createIndex(
  { title: 'text', body: 'text' },
  { weights: { title: 10, body: 1 } }
);

// A document where 'mongodb' appears in the title
// scores 10x higher than one where it only appears in the body

$meta i aggregeringspipelines

I aggregeringspipelines skal du bruge { $meta: 'textScore' } i et $addFields- eller $project-trin for at knytte scoren til dokumentet og derefter føre resultatet videre til $sort. Husk: $match-trinnet med $text skal komme først i pipelinen, så MongoDB kan beregne scoren, før andre trin transformerer dokumentstrømmen.

db.articles.aggregate([
  { $match: { $text: { $search: 'nosql tutorial' } } },
  { $addFields: { score: { $meta: 'textScore' } } },
  { $sort: { score: -1 } },
  { $limit: 5 },
  { $project: { _id: 0, title: 1, score: 1 } }
]);

Kombination af textScore-sortering med andre sorteringer

Du kan kombinere sortering efter textScore med andre sorteringsnøgler. Du kan for eksempel først sortere efter relevans og derefter efter dato som afgørelse ved lige resultater. MongoDB behandler sorteringsnøgler fra venstre mod højre, så placér textScore først for at prioritere relevans. De ekstra sorteringsnøgler bestemmer kun rækkefølgen mellem dokumenter med samme textScore-værdi.

db.articles
  .find(
    { $text: { $search: 'mongodb' } },
    { title: 1, createdAt: 1, score: { $meta: 'textScore' } }
  )
  .sort({
    score: { $meta: 'textScore' },  // relevance first
    createdAt: -1                    // then newest
  });

Filtrering efter minimumsscore

Hvis du kun vil returnere meget relevante dokumenter, kan du filtrere efter en minimumsværdi for textScore ved hjælp af udtrykket $meta i et $match-trin (i en aggregering) efter tekstmatchet. Det er ikke muligt med et direkte find()-filter; du skal bruge aggregeringspipelinen til først at beregne scoren og derefter filtrere efter den.

db.articles.aggregate([
  { $match: { $text: { $search: 'mongodb nosql' } } },
  { $addFields: { score: { $meta: 'textScore' } } },
  { $match: { score: { $gte: 1.5 } } },  // only high-relevance docs
  { $sort: { score: -1 } },
  { $project: { title: 1, score: 1 } }
]);

textScore garanterer ikke absolutte værdier

textScore-værdierne er relative inden for et forespørgselsresultat og ikke absolutte eller sammenlignelige på tværs af forskellige forespørgsler eller forskellige tilstande for samlingen. En score på 2.5 i dag kan blive til 3.1 i morgen, hvis du tilføjer flere dokumenter til samlingen (hvilket ændrer beregningerne af termfrekvensen). Brug textScore til sortering inden for et resultat, ikke som et gemt kvalitetsmål.

// Scores vary depending on collection content
// Useful for RANKING within a search result, not for thresholds
// Bad pattern:
const MIN_SCORE = 2.0;  // this threshold will drift as data grows

// Better pattern:
// Return the top N results sorted by score
db.articles
  .find({ $text: { $search: 'mongodb' } }, { score: { $meta: 'textScore' } })
  .sort({ score: { $meta: 'textScore' } })
  .limit(10);

Sideinddeling af tekstsøgningsresultater

Standardbaseret sideinddeling med skip()/limit() fungerer med tekstsøgning, men har det sædvanlige performanceproblem ved dybe forskydninger. Da resultaterne er rangeret efter relevans og ikke sorteret efter et stabilt felt, er keyset-sideinddeling ikke ligetil for tekstresultater. En almindelig tilgang er at bruge forskydningsbaseret sideinddeling på de første par sider (hvor de fleste brugere stopper) og overveje Atlas Search for dybere og mere ensartet sideinddeling i stor skala.

// Page 1 (skip 0)
db.articles
  .find({ $text: { $search: 'mongodb' } }, { score: { $meta: 'textScore' } })
  .sort({ score: { $meta: 'textScore' } })
  .skip(0).limit(10);

// Page 2 (skip 10) - gets slower on large result sets
db.articles
  .find({ $text: { $search: 'mongodb' } }, { score: { $meta: 'textScore' } })
  .sort({ score: { $meta: 'textScore' } })
  .skip(10).limit(10);

textScore i Mongoose

Når du bruger Mongoose, får du adgang til textScore via indstillingen { meta: 'textScore' } på en skemasti eller ved at bruge .select() sammen med metaprojektionen score. Mongoose omslutter MongoDB-driverens API, så det underliggende koncept er det samme – du skal blot kende Mongoose-syntaksen til projektion og sortering efter metadata.

// Mongoose text search with score projection
const results = await Article.find(
  { $text: { $search: 'mongodb nosql' } },
  { score: { $meta: 'textScore' } }  // same $meta syntax
).sort({ score: { $meta: 'textScore' } });

console.log(results.map(r => ({ title: r.title, score: r.score })));

Når textScore ikke er nok

Indbyggede tekstindekser fungerer godt til enkle anvendelser, men mangler funktioner som automatisk udfyldelse, facetteret søgning, synonymer og brugerdefinerede rangeringsfunktioner. Når du har brug for disse funktioner, tilbyder MongoDB Atlas Search (bygget på Apache Lucene) en langt mere avanceret motor til relevansscoring med BM25-scoring, boosting og forklaringsoutput til justering af relevansen.

// Atlas Search provides richer scoring with the score option
// db.articles.aggregate([
//   { $search: {
//       text: { query: 'mongodb', path: 'title', score: { boost: { value: 3 } } },
//   } },
//   { $addFields: { score: { $meta: 'searchScore' } } },
//   { $sort: { score: -1 } }
// ]);
// --> Use Atlas Search when textScore is insufficient

Hurtigt tjek

Afprøv din forståelse af sortering efter tekstscore med $meta.

Opsummering af lektionen

I denne lektion har du lært, at textScore er en relevansscore pr. dokument, som beregnes under $text-forespørgsler, at { $meta: 'textScore' } projicerer og sorterer efter denne score, og at feltvægte og termfrekvens bestemmer scorestørrelsen. Dernæst gennemgår vi begrænsningerne ved tekstindekser og hvornår Atlas Search er det bedre valg.

Gratis at komme i gang

Lær JavaScript med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser
30
Lektioner
120

Ofte stillede spørgsmål

Er lektionen “Sortering efter tekstscore med $meta” gratis?

Ja — hele teksten til “Sortering efter tekstscore med $meta” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af MongoDB Academy-kurset, skal du opgradere til CoddyKit PRO. MongoDB Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Sortering efter tekstscore med $meta”?

De lærende vil projicere og sortere efter textScore for at placere de mest relevante dokumenter øverst i resultaterne. Du øver dig i MongoDB Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på MongoDB Academy?

Der kræves ingen tidligere erfaring. MongoDB Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.

Hvor lang tid tager lektionen “Sortering efter tekstscore med $meta”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne MongoDB Academy-lektion?

Ja. Alle MongoDB Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

  1. Oprettelse af et tekstindeks på tekstfelter
  2. Kørsel af $text-forespørgsler med fraser og negation
  3. Sortering efter tekstscore med $meta
  4. Begrænsninger ved tekstindeks og hvornår Atlas Search bør bruges
← Tilbage til MongoDB Academy