MongoDB sorterer queryresultater med sort og paginerer med limit og skip — kædet sammen på en find cursor. Sammen håndterer de ordning og returnering af datasider, hvilket er essentielt for visning af resultater.
MongoDB sorterer queryresultater med sort og paginerer med limit og skip — kædet sammen på en find cursor. Sammen håndterer de ordning og returnering af datasider, hvilket er essentielt for visning af resultater.
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 tager et dokument med felt:retning (1 stigende, -1 faldende). Flere felter giver tiebreak-sortering.
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) returnerer højst n dokumenter; skip(m) springer de første m over. Sammen implementerer de offset pagination (side 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);
Uden sort er dokumentrækkefølgen ikke garanteret, så paginerede sider kan være inkonsistente. Sortér altid efter et stabilt felt (som _id) når du paginerer.
// ⚠️ 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 og pagination er fundamentale for visning af data på en brugbar måde i MongoDB — ordning af resultater og returnering af håndterbare datasider er næsten universelle behov (enhver liste, feed eller tabel i en applikation), så forståelse af dem er essentiel hverdagsviden.
At kende sort (ordning efter felter med 1/-1, med tiebreak-sortering) og limit/skip (til offset pagination — returnering af datasider) dækker de almindelige behov for præsentation af queryresultater.
To praktiske punkter er særligt vigtige: sortér altid når du paginerer (uden det er dokumentrækkefølgen ikke garanteret, hvilket forårsager inkonsistente sider med overlappende eller manglende dokumenter — en rigtig fejl, det samme problem som i SQL), og forståelse af at skip er langsom på dybe sider (den skal scanne og springe alle foregående dokumenter over) — så range-baseret (cursor) pagination (brug af sidste set _id til at hente næste side, udnyttelse af indekset uden at springe over) er langt mere effektiv for store datasæt, en værdifuld performance-teknik.
At vide at sortering på indekserede felter er effektiv mens store uindekserede sorteringer kan være langsomme eller mislykkes (in-memory sort-grænser) er også vigtig — indekser de felter du sorterer efter.
Da sortering og pagination er påkrævet for stort set enhver datapræsentation, og da konsistenskravet (sort til stabil pagination) og performance-overvejelser (skip vs range-baseret pagination, indekseret sortering) direkte påvirker korrekthed og hastighed, er forståelse af MongoDB sortering og pagination — sort, offset pagination med skip/limit, stable-sort kravet, det effektive range-baseret alternativ, og indeksering af sorteringsfelter — essentiel, hyppigt anvendt viden for opbygning af applikationer, der præsenterer MongoDB-data effektivt og performant.