MongoDB Academy · Lektion

Projektioner med inkludering kontra exkludering

Välj ut eller undertryck specifika fält i frågeresultat och förstå varför inkludering och exkludering inte kan blandas i samma projektion.

Lektion 1 av 413 steg

Projektioner med inkludering kontra exkludering är en gratis lektion i MongoDB Academy på CoddyKit. Detta är lektion 1 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.

Vad är en projektion?

En projektion är det andra argumentet till find() eller findOne() som anger för MongoDB vilka fält som ska inkluderas eller exkluderas i resultatet. I stället för att returnera hela dokumentet anger du exakt vilka fält du behöver. Det minskar bandbreddsanvändningen, minskar minnesanvändningen i din applikation och håller API-svar kompakta. Projektioner är en av de enklaste och mest effektiva frågeoptimeringarna som finns.

Inkluderingsläge: ange vad som ska returneras

I inkluderingsläge listar du de fält du vill ta emot och anger deras värde som 1. MongoDB returnerar endast dessa fält samt _id (som inkluderas som standard). Detta är den vanligaste formen av projektion eftersom den uttryckligen anger vilka fält frågan är beroende av, vilket gör avsikten tydlig för alla som läser koden.

// Return only name and email — everything else is excluded
const user = await db.collection('users').findOne(
  { email: 'alice@example.com' },
  { projection: { name: 1, email: 1 } }
);
// Result: { _id: ObjectId('...'), name: 'Alice', email: 'alice@example.com' }

Exkludera _id från resultaten

Fältet _id inkluderas alltid i inkluderingsprojektioner om du inte uttryckligen exkluderar det. Ange _id: 0 tillsammans med inkluderingsfälten för att utelämna det. Detta är användbart när du skapar API-svar som använder ett annat identifierarfält eller när du vill undvika att avslöja interna MongoDB-ID:n för klienter.

// Include name and email but suppress _id
const user = await db.collection('users').findOne(
  { email: 'alice@example.com' },
  { projection: { _id: 0, name: 1, email: 1 } }
);
// Result: { name: 'Alice', email: 'alice@example.com' }
// _id is not present

Exkluderingsläge: ange vad som ska utelämnas

I exkluderingsläge anger du fält som 0 för att ta bort dem från resultatet. Alla andra fält returneras. Detta är användbart när du vill ha nästan alla fält men behöver utelämna några känsliga eller stora fält – till exempel genom att dölja ett passwordHash-fält i frågeresultat från en generell användarfråga.

// Return all user fields EXCEPT passwordHash and internalNotes
const user = await db.collection('users').findOne(
  { email: 'alice@example.com' },
  { projection: { passwordHash: 0, internalNotes: 0 } }
);
// Result: everything except passwordHash and internalNotes

Inkludering och exkludering kan inte blandas

MongoDB tillåter inte att inkluderingsfält (1) och exkluderingsfält (0) blandas i en och samma projektion, förutom för fältet _id. Om du försöker göra det uppstår felet Projection cannot have a mix of inclusion and exclusion fields. Välj ett läge per fråga. Den enda tillåtna kombinationen är inkluderingsfält (1) tillsammans med _id: 0.

// VALID: inclusion mode with _id suppressed
{ projection: { name: 1, email: 1, _id: 0 } }

// VALID: exclusion mode
{ projection: { passwordHash: 0, secret: 0 } }

// INVALID: mixing 1 and 0 (throws an error)
// { projection: { name: 1, passwordHash: 0 } }  <- ERROR

Projektioner i find() jämfört med aggregering

I find() är projektionen det andra argumentet. I aggregeringspipen använder du steget $project, som stöder samma syntax för inkludering och exkludering samt beräknade fält och uttryck. Båda fungerar likadant när det gäller regeln att inkludering och exkludering inte får blandas, men $project är kraftfullare eftersom det kan byta namn på fält och lägga till beräknade värden.

// find() projection
db.users.find({}, { name: 1, email: 1, _id: 0 });

// Equivalent in aggregation with $project
db.users.aggregate([
  { $project: { name: 1, email: 1, _id: 0 } }
]);

Projektioner och täckta frågor

En täckt fråga är en fråga där både filterfälten och projektionsfälten finns helt och hållet i ett och samma index. MongoDB kan besvara en täckt fråga direkt från indexet utan att läsa det faktiska dokumentet från disken. Projektioner är avgörande för täckta frågor: om du projicerar ett fält som inte finns i indexet måste MongoDB hämta dokumentet, vilket gör att täckningsfördelen försvinner.

// Index on { email: 1, name: 1 }
db.users.createIndex({ email: 1, name: 1 });

// Covered query — filter + projection both satisfied by the index
db.users.find(
  { email: 'alice@example.com' },
  { name: 1, email: 1, _id: 0 }  // _id must be excluded for full coverage
).explain('executionStats');
// Look for 'totalDocsExamined: 0' in the output

Projektioner med Mongoose

I Mongoose kan du skicka en projektion som en sträng eller ett objekt till .select(). En blankstegsseparerad sträng med + för inkludering och - för exkludering är vanlig. Fält som markerats med select: false i schemat (till exempel passwordHash) exkluderas från resultaten som standard och måste inkluderas uttryckligen med +passwordHash.

// Mongoose: string projection (+ include, - exclude)
const users = await User.find({}).select('name email -_id');

// Object projection
const user = await User.findOne({ email: 'a@b.com' }).select({ name: 1, email: 1, _id: 0 });

// Schema-level default exclusion
const userSchema = new mongoose.Schema({
  email: String,
  passwordHash: { type: String, select: false }  // excluded by default
});

Prestandafördelar med projektioner

Projektioner förbättrar prestandan på tre sätt: (1) de minskar mängden data som läses från disken när projektionen överensstämmer med ett index, (2) de minskar nätverksbandbredden mellan MongoDB-servern och din applikation, och (3) de minskar mängden minne som applikationen måste allokera för att lagra frågeresultaten. För stora dokument eller API:er med hög genomströmning kan projektioner minska svarsstorleken med 80 procent eller mer.

Projicera beräknade värden i aggregering

Steget $project i en aggregering går längre än enkel inkludering och exkludering. Du kan beräkna nya fält med hjälp av uttryck – till exempel sammanfoga strängar, utföra aritmetiska beräkningar eller hämta delar av ett datum. På så sätt kan du omforma dokumentens struktur på serversidan innan resultaten skickas till applikationen, vilket minskar bearbetningen på klientsidan.

db.orders.aggregate([
  {
    $project: {
      orderId: '$_id',
      _id: 0,
      totalWithTax: { $multiply: ['$subtotal', 1.1] },  // computed field
      year: { $year: '$createdAt' }                       // date extraction
    }
  }
]);

Projicera alltid bort känsliga fält

Returnera aldrig känsliga fält som passwordHash, apiKey, ssn eller creditCardNumber i generella frågor. Använd exkluderingsprojektioner eller select: false på schemanivå för att säkerställa att dessa fält aldrig råkar visas i API-svar. Försvar på djupet innebär att du använder projektioner i datalagret som en extra skyddsåtgärd, även om applikationen redan tar bort dessa fält från svaren.

Snabbtest

Testa dina kunskaper om MongoDB- och NoSQL-databaser från den här lektionen.

Besvara frågan i den interaktiva lektionen

Sammanfattning av lektionen

I den här lektionen har du lärt dig att inkluderingsprojektioner (värdet 1) endast returnerar de listade fälten, att exkluderingsprojektioner (värdet 0) returnerar alla fält utom de listade och att inkludering och exkludering inte får blandas, förutom _id: 0 med inkluderingsfält. Härnäst utforskar vi projektion av nästlade fält och arrayer med punktnotation och $slice.

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

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Projektioner med inkludering kontra exkludering” gratis?

Ja – hela texten till ”Projektioner med inkludering kontra exkludering” 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 ”Projektioner med inkludering kontra exkludering”?

Välj ut eller undertryck specifika fält i frågeresultat och förstå varför inkludering och exkludering inte kan blandas i samma projektion. 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 1 av 4.

Hur lång tid tar lektionen ”Projektioner med inkludering kontra exkludering”?

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

Projektioner med inkludering kontra exkludering
Projicera nästlade fält och arrayfält
Arrayprojektionerna $ och $elemMatch
Bästa praxis för projektioner i API-svar

← Tillbaka till MongoDB Academy