Projicera nästlade fält och arrayfält
Använd punktnotation och operatorn $slice för att projicera delar av arrayer och nästlade underdokument.
Projicera nästlade fält och arrayfält ä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.
Projicera nästlade fält med punktnotation
Om du vill projicera ett specifikt fält från ett inbäddat underdokument använder du punktnotation i projektionsnyckeln. Om ett dokument till exempel har ett underdokument address kan du projicera endast address.city utan att returnera hela address-objektet. MongoDB följer den nästlade sökvägen och returnerar endast det angivna bladfältet, samtidigt som det överordnade fältets omslutande struktur behålls i resultatet.
// Document shape: { name, address: { street, city, zip }, email }
const user = await db.collection('users').findOne(
{ email: 'alice@example.com' },
{ projection: { name: 1, 'address.city': 1, _id: 0 } }
);
// Result: { name: 'Alice', address: { city: 'Austin' } }
// street and zip are excluded; only city is returned inside addressExkludera nästlade fält
Precis som med fält på toppnivå kan du exkludera specifika nästlade fält och samtidigt returnera resten av underdokumentet. Om du använder 'address.zip': 0 returneras hela address-objektet förutom fältet zip. Detta är användbart när du vill dölja underfält som endast är avsedda för internt bruk, men visa resten av ett nästlat objekt för klienten.
// Return everything except address.zip
const user = await db.collection('users').findOne(
{ email: 'alice@example.com' },
{ projection: { 'address.zip': 0, passwordHash: 0 } }
);
// Result includes address.street and address.city but not address.zipArrayfält i projektioner
När ett projicerat fält är en array returnerar MongoDB hela arrayen som standard. Om ett användardokument har en tags-array med tio element returnerar projektionen tags: 1 alla tio. Om du vill styra hur mycket av en array som returneras behöver du $slice, $ eller $elemMatch – de tre arrayspecifika projektionsoperatorerna.
// Returns the entire tags array
const post = await db.collection('posts').findOne(
{ slug: 'intro-to-mongodb' },
{ projection: { title: 1, tags: 1, _id: 0 } }
);
// Result: { title: '...', tags: ['mongodb', 'nosql', 'tutorial', ...] }Dela upp arrayer med $slice
Projektionsoperatorn $slice begränsar antalet arrayelement som returneras. Ange ett positivt heltal för att returnera de första N elementen eller ett negativt heltal för att returnera de sista N elementen. Du kan även ange en array med två element, [skip, limit], för att hoppa över ett antal element och sedan returnera de följande N elementen. $slice är det enklaste sättet att paginera eller förhandsvisa innehållet i en array.
// Return only the first 3 comments from a post
db.posts.findOne(
{ slug: 'intro-to-mongodb' },
{ projection: { title: 1, comments: { $slice: 3 } } }
);
// Return the last 5 comments
db.posts.findOne(
{ slug: 'intro-to-mongodb' },
{ projection: { title: 1, comments: { $slice: -5 } } }
);
// Skip 10 comments, then return the next 5
db.posts.findOne(
{ slug: 'intro-to-mongodb' },
{ projection: { title: 1, comments: { $slice: [10, 5] } } }
);Projicera nästlade underfält i arrayer
Du kan projicera ett fält inuti en array med underdokument genom att använda punktnotation i en inkluderingsprojektion. Ett orders-dokument kan till exempel ha en items-array där varje element har productId, qty och price. Projektionen 'items.qty': 1 returnerar hela items-arrayen, men endast fältet qty i varje element.
// Return items array with only the qty field in each element
db.orders.findOne(
{ _id: ObjectId('o1') },
{ projection: { 'items.qty': 1, 'items.productId': 1, _id: 0 } }
);
// Result:
// { items: [{ productId: ObjectId('p1'), qty: 2 }, { productId: ObjectId('p2'), qty: 1 }] }Exkludera ett nästlat underfält i en array
På motsvarande sätt kan du exkludera specifika underfält från arrayelement. En employees-samling kan till exempel lagra lön i ett underdokument kallat compensation i varje element i en array. Projektionen 'positions.compensation': 0 returnerar positions-arrayen med de känsliga löneuppgifterna borttagna från varje element.
// Exclude compensation from every element of the positions array
db.employees.findOne(
{ name: 'Alice' },
{ projection: { 'positions.compensation': 0 } }
);Projicera flera nästlade sökvägar
Du kan projicera flera nästlade fält från samma underdokument eller array i en enda projektion. Varje punktnoterad sökväg hanteras separat. Denna kombinerbarhet låter dig hämta exakt den del av ett dokument som frågan behöver, utan att ta med irrelevant nästlad data som skulle göra svaret större.
// Get shipping address city and order total only
db.orders.find(
{ status: 'shipped' },
{
projection: {
'shippingAddress.city': 1,
'shippingAddress.country': 1,
total: 1,
_id: 0
}
}
);Djup nästling med punktnotation
Punktnotation kan gå flera nivåer djupt. Om du har ett dokument med meta.seo.keywords kan du projicera exakt den sökvägen. MongoDB returnerar de yttre omslutande fälten (meta och seo), men inkluderar endast bladet keywords och tar bort alla andra syskonfält på varje nivå.
// Document: { title, meta: { seo: { keywords: [...], description: '...' }, author: '...' } }
db.articles.findOne(
{ slug: 'my-article' },
{ projection: { title: 1, 'meta.seo.keywords': 1, _id: 0 } }
);
// Result: { title: '...', meta: { seo: { keywords: [...] } } }
// meta.seo.description and meta.author are excludedProjektion och indextäckning för nästlade fält
För att en fråga ska vara täckt (helt kunna besvaras från indexet utan att dokumenten berörs) måste projektionen endast innehålla fält som finns i indexet, inklusive nästlade fält. Ett sammansatt index på { 'address.city': 1, name: 1 } kan täcka en fråga som filtrerar på address.city och endast projicerar address.city och name (med _id: 0). Täckta frågor ger lägsta möjliga svarstid.
// Create an index on nested field
db.users.createIndex({ 'address.city': 1, name: 1 });
// Covered query — both filter and projection are inside the index
db.users.find(
{ 'address.city': 'Austin' },
{ projection: { 'address.city': 1, name: 1, _id: 0 } }
).explain('executionStats');
// totalDocsExamined should be 0$slice i Mongoose
Mongoose har ingen inbyggd $slice-förkortning i frågebyggaren, men du kan skicka ett projektionsobjekt direkt. Använd { fieldName: { $slice: N } } i Mongoose-anropet .select() om du skickar ett objekt, eller skicka projektionen som det andra argumentet till .find(). Drivrutinen vidarebefordrar den till MongoDB utan ändringar.
// Mongoose: return title and first 5 comments using $slice
const post = await Post.findOne(
{ slug: 'intro-to-mongodb' },
{ title: 1, comments: { $slice: 5 }, _id: 0 }
);
// Alternatively as a Mongoose query
const post2 = await Post
.findOne({ slug: 'intro-to-mongodb' })
.select({ title: 1, comments: { $slice: 5 }, _id: 0 });Vanliga fallgropar med nästlade projektioner
En vanlig fallgrop är att en nästlad arrayfältprojektion kräver punktnotation, men MongoDB returnerar hela arrayens omslutande struktur. Du kan inte projicera enskilda arrayelement med hjälp av index (till exempel filtrerar items.0 inte fram endast det första elementet i projektionen – använd $slice: 1 för det). Du kan inte heller blanda projektion av ett överordnat fält och ett underfält i samma sökväg: projicera antingen address eller address.city, inte båda.
Snabbtest
Testa dina kunskaper om MongoDB- och NoSQL-databaser från den här lektionen.
Sammanfattning av lektionen
I den här lektionen har du lärt dig att punktnotation projicerar specifika nästlade fält från underdokument och arrayer, att $slice begränsar antalet arrayelement som returneras och att projektion av nästlade underfält i arrayer endast inkluderar det angivna bladet i varje arrayelement. Härnäst utforskar vi $- och $elemMatch-arrayprojektioner för att returnera ett enda matchande element från en array.
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 ”Projicera nästlade fält och arrayfält” gratis?
Ja – hela texten till ”Projicera nästlade fält och arrayfält” 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 ”Projicera nästlade fält och arrayfält”?
Använd punktnotation och operatorn $slice för att projicera delar av arrayer och nästlade underdokument. 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 ”Projicera nästlade fält och arrayfält”?
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