MongoDB Academy · Pelajaran

Pengisihan Dengan sort() dan Berbilang Kekunci

Pelajar akan mengisih hasil pertanyaan mengikut satu atau lebih medan dalam tertib menaik dan menurun serta melihat cara pengisihan berinteraksi dengan penggunaan indeks.

Pelajaran 1 daripada 413 langkah

Pengisihan Dengan sort() dan Berbilang Kekunci ialah pelajaran MongoDB Academy percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran MongoDB Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus MongoDB Academy merangkumi sejumlah 4 pelajaran.

Menyusun Hasil Pertanyaan Dengan sort()

Kaedah sort() yang ditambahkan pada kursor find() memberitahu MongoDB supaya mengembalikan dokumen dalam susunan tertentu. Hantar objek yang setiap kekuncinya ialah nama medan dan setiap nilainya ialah 1 (menaik) atau -1 (menurun). Pengisihan berlaku pada pelayan sebelum dokumen dihantar kepada klien, jadi anda menerima hasil yang tersusun tanpa mengira bilangan dokumen yang sepadan.

// Ascending: oldest first
db.posts.find({}).sort({ createdAt: 1 });

// Descending: newest first
db.posts.find({}).sort({ createdAt: -1 });

// With Node.js driver
const posts = await db.collection('posts')
  .find({})
  .sort({ createdAt: -1 })
  .toArray();

Mengisih Mengikut Berbilang Kekunci

MongoDB mengisih mengikut kekunci pertama dahulu, kemudian menggunakan kekunci seterusnya untuk menyelesaikan seri. Hantar berbilang medan dalam objek pengisihan. Susunan kekunci penting: kekunci pertama ialah pengisihan utama dan kekunci kedua ialah pemecah seri. Contoh biasa ialah mengisih produk mengikut category secara menaik, kemudian mengikut price secara menurun dalam setiap kategori.

// Primary sort: category ASC; secondary sort: price DESC
db.products.find({}).sort({ category: 1, price: -1 });

// Sorting users by role then by username alphabetically
db.users.find({}).sort({ role: 1, username: 1 });

// Sorting blog posts: featured first, then newest
db.posts.find({}).sort({ isFeatured: -1, createdAt: -1 });

Interaksi Pengisihan dan Indeks

Apabila medan pengisihan sepadan dengan indeks, MongoDB boleh memenuhi pengisihan tanpa memuatkan dan mengisih semua dokumen dalam memori. Sebaliknya, MongoDB menelusuri indeks mengikut arah yang diminta. Ini dipanggil pengisihan indeks dan jauh lebih pantas daripada pengisihan dalam memori, khususnya pada collection yang besar. Sentiasa cipta indeks yang meliputi operasi pengisihan anda yang paling kerap digunakan.

// Create an index that supports category-then-price sorting
db.products.createIndex({ category: 1, price: -1 });

// This query now sorts via index — no in-memory sort needed
db.products.find({ isActive: true }).sort({ category: 1, price: -1 });

// verify with explain
db.products.find({}).sort({ category: 1, price: -1 }).explain('executionStats');

Had Pengisihan Dalam Memori 32 MB

Jika pengisihan tidak dapat menggunakan indeks, MongoDB mesti memuatkan semua dokumen yang sepadan ke dalam memori untuk mengisihnya. Pengisihan dalam memori ini mempunyai had tetap sebanyak 32 MB. Jika dokumen yang sepadan melebihi 32 MB, pengisihan gagal dengan Executor error: OperationFailed: Sort exceeded memory limit. Penyelesaiannya ialah menambah indeks yang menyokong pengisihan atau menggunakan allowDiskUse: true dalam saluran agregasi.

// In an aggregation, allow spilling to disk for large sorts
db.logs.aggregate(
  [{ $sort: { timestamp: -1 } }],
  { allowDiskUse: true }  // allows spilling sort to temporary disk files
);

Arah Pengisihan dan Arah Indeks Mesti Selaras

Untuk indeks gabungan menyokong pengisihan gabungan, arahnya mesti selaras—sama ada sepadan tepat atau diterbalikkan sepenuhnya. Indeks pada { a: 1, b: 1 } menyokong pengisihan pada { a: 1, b: 1 } (imbasan ke hadapan) dan { a: -1, b: -1 } (imbasan ke belakang), tetapi tidak boleh menyokong { a: 1, b: -1 } atau { a: -1, b: 1 }. Pengisihan dengan arah bercampur memerlukan indeks yang sepadan tepat dengan arah tersebut.

// This index supports { a: 1, b: -1 } sorts
db.collection.createIndex({ a: 1, b: -1 });

// Supported: forward
db.collection.find({}).sort({ a: 1, b: -1 });
// Supported: backward (reverse scan)
db.collection.find({}).sort({ a: -1, b: 1 });
// NOT supported by this index:
// db.collection.find({}).sort({ a: 1, b: 1 });

Pengisihan Mengikut Susunan Semula Jadi

Kunci isihan $natural mengembalikan dokumen mengikut susunan sisipan semula jadi pada cakera. { $natural: 1 } mengembalikan dokumen mengikut susunan sisipan; { $natural: -1 } mengembalikannya dalam susunan terbalik. Kaedah ini memintas semua indeks dan jarang digunakan dalam persekitaran pengeluaran—ia terutamanya berguna untuk collection terhad, yang mengekalkan susunan sisipan ketat bagi beban kerja seperti log.

// Capped collection — return events in insertion order
db.eventLog.find({}).sort({ $natural: 1 });

// Reverse insertion order
db.eventLog.find({}).sort({ $natural: -1 });

Menggabungkan sort() dengan limit() dan skip()

Pengisihan hampir sentiasa digabungkan dengan limit() untuk mendapatkan hanya N hasil teratas, dan kadangkala dengan skip() untuk hasil berhalaman. Susunan operasi ialah: penapisan → pengisihan → langkau → had. MongoDB menerapkannya dalam urutan ini tanpa mengira urutan anda merangkaikannya dalam kod pemacu. Mengisih sebelum mengehadkan hasil membolehkan anda mendapatkan hasil “10 teratas” dengan betul.

// Top 10 highest-rated products in the 'electronics' category
const topProducts = await db.collection('products')
  .find({ category: 'electronics', isActive: true })
  .sort({ rating: -1 })
  .limit(10)
  .toArray();

// Page 3 of results (20 per page)
const page3 = await db.collection('products')
  .find({})
  .sort({ createdAt: -1 })
  .skip(40)   // skip pages 1 and 2
  .limit(20)
  .toArray();

Pengisihan dalam Mongoose

Pembina pertanyaan Mongoose menyediakan .sort() dengan sintaks yang sama seperti pemacu natif, serta bentuk rentetan yang lebih mudah. Hantar rentetan nama medan yang diawali dengan + (menaik) atau - (menurun), dan pisahkan dengan ruang. Kedua-dua bentuk adalah setara dan pemacu menyusunnya menjadi dokumen isihan MongoDB yang sama.

// Object syntax
const posts = await Post.find({}).sort({ createdAt: -1, title: 1 });

// String syntax — '-' means descending, no prefix means ascending
const posts2 = await Post.find({}).sort('-createdAt title');

// Multi-field sort with limit in a chain
const recent = await Post
  .find({ isPublished: true })
  .sort('-createdAt')
  .limit(5)
  .select('title createdAt');

Mengisih Medan Null dan Medan yang Tiada

Dalam hasil isihan MongoDB, dokumen yang medan isihannya tiada atau bernilai null diisih seolah-olah nilai medan itu ialah null. Dalam susunan menaik, nilai null dan nilai yang tiada muncul terlebih dahulu (sebelum sebarang nilai lain). Dalam susunan menurun, nilai tersebut muncul terakhir. Beri perhatian kepada tingkah laku ini apabila sesetengah dokumen tiada medan isihan—ia boleh menyebabkan susunan yang tidak dijangka dalam collection dengan skema bercampur.

Isihan Stabil dengan Kunci _id Sekunder

Isihan MongoDB tidak dijamin stabil apabila dua dokumen mempunyai nilai yang sama untuk kunci isihan—susunan relatifnya tidak ditentukan dan mungkin berubah antara pertanyaan. Untuk mendapatkan susunan yang stabil dan berketentuan, sentiasa sertakan _id sebagai pemecah seri terakhir. Oleh sebab _id adalah unik, ia menjamin susunan yang konsisten walaupun kunci isihan utama adalah sama.

// Stable sort: primary sort by rating DESC, tiebreaker by _id ASC
db.products.find({}).sort({ rating: -1, _id: 1 });

// Without _id as tiebreaker, documents with the same rating
// may appear in different order on repeated queries

Mengesahkan Isihan Menggunakan Indeks

Jalankan explain('executionStats') dan cari peringkat SORT dalam pelan pelaksanaan. Jika anda melihat IXSCAN mengalir terus ke kursor tanpa peringkat SORT, isihan dilaksanakan oleh indeks (keadaan yang ideal). Jika terdapat peringkat SORT, isihan berlaku dalam memori dan indeks mungkin membantu. Periksa juga memUsage dalam peringkat SORT untuk memahami jumlah memori yang digunakan oleh isihan.

const plan = db.products.find({}).sort({ rating: -1 }).explain('executionStats');
// Look in plan.executionStats.executionStages for 'SORT' stage
// 'IXSCAN' without 'SORT' = index sort (best)
// 'SORT' stage = in-memory sort (may need an index)

Semakan Pantas

Uji pemahaman anda tentang konsep MongoDB & pangkalan data NoSQL daripada pelajaran ini.

Jawab dalam pelajaran interaktif

Ulang Kaji Pelajaran

Dalam pelajaran ini, anda telah mempelajari bahawa: sort() menerima dokumen pasangan medan-arah, dengan 1 bermaksud menaik dan -1 bermaksud menurun, isihan gabungan menggunakan medan seterusnya sebagai pemecah seri, dan padanan dengan indeks mengelakkan had isihan dalam memori sebanyak 32 MB. Seterusnya, kita akan meneroka penomboran beranjak menggunakan skip dan limit serta pertukaran prestasinya pada skala besar.

Percuma untuk bermula

Pelajari JavaScript dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 30
Pelajaran: 120

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Pengisihan Dengan sort() dan Berbilang Kekunci” percuma?

Ya — teks penuh “Pengisihan Dengan sort() dan Berbilang Kekunci” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus MongoDB Academy, tingkat taraf kepada CoddyKit PRO. Kursus MongoDB Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Pengisihan Dengan sort() dan Berbilang Kekunci”?

Pelajar akan mengisih hasil pertanyaan mengikut satu atau lebih medan dalam tertib menaik dan menurun serta melihat cara pengisihan berinteraksi dengan penggunaan indeks. Anda berlatih MongoDB Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan MongoDB Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran MongoDB Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Berapa lamakah pelajaran “Pengisihan Dengan sort() dan Berbilang Kekunci” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran MongoDB Academy ini?

Ya. Setiap pelajaran MongoDB Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

Pengisihan Dengan sort() dan Berbilang Kekunci
Skip dan Limit: Penomboran Berhalaman Berasaskan Offset
Penomboran Berhalaman Keyset Dengan Pertanyaan Julat
Menggabungkan Pengisihan, Skip, Limit dan Unjuran

← Kembali ke MongoDB Academy