MongoDB Academy · Lektion

Köra $text-frågor med fraser och negation

Ni frågar med $text med citerade fraser, negerade termer och uttryck med flera ord och undersöker hur MongoDB matchar dokument.

Lektion 2 av 413 steg

Köra $text-frågor med fraser och negation är en gratis lektion i MongoDB Academy på CoddyKit. Detta är lektion 2 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för MongoDB Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i MongoDB Academy innehåller totalt 4 lektioner.

Frågeoperatorn $text

När ett textindex finns kan Ni göra nyckelordssökningar med $text-operatorn i ett find()-filter. Värdet är ett objekt med en $search-sträng som innehåller de ord eller fraser Ni söker efter. MongoDB tokeniserar Er söksträng på samma sätt som de indexerade fälten och returnerar sedan dokument där minst ett indexerat fält innehåller en matchande token.

// Simple keyword search
db.articles.find({ $text: { $search: 'mongodb index' } });

// This returns documents that contain 'mongodb' OR 'index'
// (or their stemmed variants) in any indexed field

Sökningar med flera ord: OR-semantik

Som standard använder en $text-sökning med flera ord OR-semantik: ett dokument matchar om det innehåller något av orden. 'mongodb index' returnerar alltså dokument som innehåller 'mongodb' eller 'index' eller båda. Relevanspoängen (textScore) är högre för dokument som innehåller fler av söktermerna, men alla matchande dokument returneras oavsett.

// OR semantics: matches docs with 'mongodb' OR 'index'
db.articles.find(
  { $text: { $search: 'mongodb index' } },
  { score: { $meta: 'textScore' }, title: 1 }
).sort({ score: { $meta: 'textScore' } });

// Documents with BOTH words score higher and appear first

Frassökningar med dubbla citattecken

Om Ni vill kräva en exakt fras omsluter Ni den med escapade dubbla citattecken i $search-strängen. En frassökning kräver att orden förekommer tillsammans och i rätt ordning. Dokument som bara innehåller vissa av frasens ord, men inte den exakta sekvensen, matchar inte. Frassökningar är mer precisa, men kan missa relevanta dokument med något annorlunda formulering.

// Phrase search: 'database index' must appear as a phrase
db.articles.find({
  $text: { $search: '"database index"' }
});

// Only matches documents where 'database' and 'index'
// appear together as a phrase, not just anywhere in the text

// Combined phrase and keyword:
db.articles.find({
  $text: { $search: '"database index" mongodb' }
});

Negation med minustecknet

Inled ett ord med ett minustecken (-) för att utesluta dokument som innehåller ordet. Ni kan inte använda negation ensam – den måste kombineras med minst en positiv sökterm. Negation är användbart när ett nyckelord är för brett och Ni vill filtrera bort en specifik oönskad betydelse, som 'java -coffee' för att hitta programmeringsartiklar om Java, inte om drycken.

// Exclude results containing 'relational'
db.articles.find({
  $text: { $search: 'database -relational' }
});

// Find NoSQL content but exclude SQL mentions
db.articles.find({
  $text: { $search: 'nosql document store -sql -table' }
});

Kombinera fraser och negation

Ni kan fritt blanda fraser, nyckelord och negation i en enda $search-sträng. MongoDB bearbetar varje term separat: grupper inom citattecken är frassökningar, ord med minustecken framför är undantag och återstående vanliga ord är valfria nyckelordsmatcher. Denna kombinerbarhet låter Er uttrycka måttligt komplex söklogik utan en särskild sökmotor.

// Find articles about 'index tuning' that mention 'mongodb'
// but exclude anything about 'elasticsearch'
db.articles.find({
  $text: {
    $search: '"index tuning" mongodb -elasticsearch'
  }
});

Skiftlägesokänslighet

$text-sökningar är som standard skiftlägesokänsliga. MongoDB konverterar alla tokenvärden till gemener både vid indexering och sökning, så 'MongoDB', 'MONGODB' och 'mongodb' matchar samma indexerade tokenvärden. Ni behöver inte normalisera sökindata innan Ni kör en $text-fråga.

// All three queries return the same results
db.articles.find({ $text: { $search: 'MongoDB' } });
db.articles.find({ $text: { $search: 'MONGODB' } });
db.articles.find({ $text: { $search: 'mongodb' } });

Alternativet $language

Som standard använder $text det språk som konfigurerats i textindexet. Ni kan åsidosätta detta per fråga med alternativet $language. Det är användbart för samlingar med flerspråkigt innehåll där dokument på olika språk bör sökas med rätt lista över stoppord och rätt stemmingalgoritm.

// Override language for a specific search
db.articles.find({
  $text: {
    $search: 'base de datos',
    $language: 'spanish'
  }
});

// Or disable stop words and stemming entirely
db.articles.find({
  $text: {
    $search: 'databases',
    $language: 'none'  // exact token match, no stemming
  }
});

Alternativet $caseSensitive

Även om skiftlägesokänslig sökning är standard kan Ni aktivera skiftlägeskänslig textsökning med $caseSensitive: true. Detta behövs sällan, men är användbart när innehållet innehåller skiftlägeskänsliga identifierare som klassnamn eller kommandonamn. Observera att skiftlägeskänslig textsökning är betydligt långsammare eftersom den inte kan använda de indexposter som redan konverterats till gemener.

// Case-sensitive search (slower)
db.docs.find({
  $text: {
    $search: 'MongoDB',
    $caseSensitive: true  // 'mongodb' would NOT match
  }
});

// Case-insensitive (default, fast)
db.docs.find({
  $text: { $search: 'mongodb' }  // matches MongoDB, MONGODB, mongodb
});

Alternativet $diacriticSensitive

Som standard är MongoDBs textsökning okänslig för diakritiska tecken: 'café' och 'cafe' behandlas som samma ord. Ni kan aktivera $diacriticSensitive: true för att skilja mellan tecken med och utan accent. Detta har betydelse för språk som franska, tyska och spanska, där diakritiska tecken kan ändra betydelsen. Precis som skiftlägeskänslig sökning är diakritikkänslig sökning långsammare eftersom den kringgår förnormaliserade indexposter.

// Diacritic-insensitive (default)
db.articles.find({ $text: { $search: 'cafe' } });
// Matches: 'cafe', 'café', 'cáfe'

// Diacritic-sensitive
db.articles.find({
  $text: {
    $search: 'cafe',
    $diacriticSensitive: true
  }
});
// Only matches: 'cafe' (not 'café')

Textsökning i aggregeringspipelines

Ni kan använda $text i aggregeringspipelines genom att placera ett $match-steg med textfiltret som det allra första steget. Då kan MongoDB skicka textsökningen till indexet innan efterföljande pipelinesteg tillämpas. Därefter kan Ni projicera textScore, gruppera resultaten efter kategori eller begränsa antalet träffar – allt på serversidan.

db.articles.aggregate([
  // MUST be the first stage to use the text index
  { $match: { $text: { $search: 'mongodb aggregation' } } },
  { $addFields: { score: { $meta: 'textScore' } } },
  { $sort: { score: -1 } },
  { $limit: 10 },
  { $project: { title: 1, score: 1, category: 1 } }
]);

Räkna resultat från textsökningar

Om Ni vill räkna hur många dokument som matchar en textfråga använder Ni countDocuments() med $text-filtret eller lägger till ett $count-steg sist i en aggregeringspipeline. Undvik att använda count() (föråldrad) och tänk på att estimatedDocumentCount() inte kan ta emot ett filter – använd alltid countDocuments() för filtrerade antal.

// Count matching documents
const total = await db.articles.countDocuments({
  $text: { $search: 'mongodb tutorial' }
});
console.log('Matches:', total);

// In an aggregation pipeline
db.articles.aggregate([
  { $match: { $text: { $search: 'mongodb tutorial' } } },
  { $count: 'total' }
]);

Snabbkontroll

Testa Er förståelse av alternativen för $text-frågor från den här lektionen.

Sammanfattning av lektionen

I den här lektionen har Ni lärt Er att vanliga ord använder OR-semantik och matchar valfri sökterm, att fraser inom dubbla citattecken kräver en exakt ordsekvens och att ord med minustecken framför utesluter dokument som innehåller termen. Härnäst sorterar vi resultat efter textens relevanspoäng med hjälp av $meta.

Gratis att börja

Lär dig JavaScript med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser
30
Lektioner
120

Vanliga frågor

Är lektionen ”Köra $text-frågor med fraser och negation” gratis?

Ja – hela texten till ”Köra $text-frågor med fraser och negation” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i MongoDB Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i MongoDB Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Köra $text-frågor med fraser och negation”?

Ni frågar med $text med citerade fraser, negerade termer och uttryck med flera ord och undersöker hur MongoDB matchar dokument. Ni övar på MongoDB Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig MongoDB Academy?

Du behöver inga förkunskaper. Utbildningen i MongoDB Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Köra $text-frågor med fraser och negation”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här MongoDB Academy-lektionen?

Ja. Varje MongoDB Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

  1. Skapa ett textindex för strängfält
  2. Köra $text-frågor med fraser och negation
  3. Sortera efter textpoäng med $meta
  4. Begränsningar hos textindex och när Atlas Search bör användas
← Tillbaka till MongoDB Academy