MongoDB sorterar frågeresultat med sort och sidnumrerar med limit och skip — kedjade på en find-markör. Tillsammans hanterar de sortering och returnering av datasidor, vilket är väsentligt för att visa resultat.
MongoDB sorterar frågeresultat med sort och sidnumrerar med limit och skip — kedjade på en find-markör. Tillsammans hanterar de sortering och returnering av datasidor, vilket är väsentligt för att visa resultat.
db.users.find().sort({ age: 1 }); // ascending by age (1 = asc)
db.users.find().sort({ age: -1 }); // descending (-1 = desc)
db.users.find().sort({ country: 1, name: 1 }); // by country, then name (tie-break)
db.users.find().sort({ createdAt: -1 }); // newest first (common)
sort tar ett dokument med field:direction (1 stigande, -1 fallande). Flera fält ger departörsresultat.
db.users.find().sort({ name: 1 }).limit(10); // first 10 (page 1)
db.users.find().sort({ name: 1 }).skip(10).limit(10); // skip 10, take 10 (page 2)
// page N: .skip((N-1) * pageSize).limit(pageSize)
limit(n) returnerar högst n dokument; skip(m) hoppar över de första m. Tillsammans implementerar de offset-sidnumrering (sida N via skip + limit).
// ❌ pagination without sort → inconsistent order (pages may overlap/skip)
db.users.find().skip(10).limit(10);
// ✅ sort by a stable field for consistent pages
db.users.find().sort({ _id: 1 }).skip(10).limit(10);
Utan sort är dokumentordningen inte garanterad, så sidnumrerade sidor kan vara inkonsistenta. Sortera alltid efter ett stabilt fält (som _id) när du sidnumrerar.
// ⚠️ skip(1000000) must scan/skip a million docs → slow on deep pages
// ✅ range-based (cursor) pagination — far more efficient for large datasets
db.users.find({ _id: { $gt: lastSeenId } }).sort({ _id: 1 }).limit(10);
// → use the last document's _id to fetch the next page (uses the index, no skipping)
Sorting on an INDEXED field is efficient. Sorting a large result set WITHOUT an index
requires an in-memory sort (limited size — can fail/be slow for big sorts).
→ Index fields you sort by.
Sortering och sidnumrering är fundamentala för att visa data på ett användbart sätt i MongoDB — sortering av resultat och returnering av hanterbara sidor är nästan universella behov (alla listor, flöden eller tabeller i en applikation), så att förstå dem är väsentlig vardagskunskap.
Att kunna sort (sortering efter fält med 1/-1, med departörsresultat) och limit/skip (för offset-sidnumrering — returnering av datasidor) täcker de vanliga behoven för att presentera frågeresultat.
Två praktiska punkter är särskilt viktiga: sortera alltid när du sidnumrerar (utan det är dokumentordningen inte garanterad, vilket orsakar inkonsistenta sidor som överlappar eller hoppar över dokument — en verklig bugg, samma problem som i SQL), och att förstå att skip är långsamt på djupa sidor (det måste skanna och hoppa över alla föregående dokument) — så intervalbaserad (markör) sidnumrering (använder det senast sedda _id för att hämta nästa sida, utnyttjar indexet utan att hoppa över) är mycket mer effektiv för stora dataset, en värdefull prestandateknik.
Att veta att sortering på indexerade fält är effektiv medan stora indexerade sorteringar kan vara långsamma eller misslyckas (in-memory-sorterings begränsningar) är också viktigt — indexera fält du sorterar efter.
Eftersom sortering och sidnumrering krävs för nästan all datavisa, och eftersom konsistenskravet (sortera för stabil sidnumrering) och prestandaöverväganden (skip kontra intervalbaserad sidnumrering, indexerad sortering) direkt påverkar korrekthet och hastighet, är det väsentligt att förstå MongoDB-sortering och sidnumrering — sort, offset-sidnumrering med skip/limit, det stabila-sorterings-kravet, det effektiva intervalbaserade alternativet och indexering av sorteringsfält — väsentlig, ofta använd kunskap för att bygga applikationer som presenterar MongoDB-data effektivt och prestandamässigt.