Mengurutkan Berdasarkan Skor Teks dengan $meta
Peserta didik akan memproyeksikan dan mengurutkan berdasarkan textScore untuk menampilkan dokumen yang paling relevan di bagian atas hasil.
Mengurutkan Berdasarkan Skor Teks dengan $meta adalah pelajaran MongoDB Academy gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar MongoDB Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus MongoDB Academy mencakup 4 pelajaran total.
Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.
What Is textScore?
When a $text query runs, MongoDB computes a relevance score for every matching document called the textScore. This score reflects how well the document matches the search terms: more occurrences of the search terms, matches in higher-weighted fields, and matches of rarer tokens all increase the score. By default, results are not sorted by score; you must request the sort explicitly.
Projecting textScore With $meta
To include the relevance score in your results, add a projection field using { $meta: 'textScore' }. You can name this field anything you like (conventionally score). The $meta expression reads metadata computed during query execution—textScore is the only metadata value currently supported in this context.
db.articles.find(
{ $text: { $search: 'mongodb performance' } },
{
title: 1,
score: { $meta: 'textScore' } // project the relevance score
}
);Sorting by textScore
To sort results by relevance, pass { score: { $meta: 'textScore' } } to .sort(). MongoDB sorts in descending order by default for textScore (highest relevance first). You must project the score field in the same query when sorting by it—if you omit the projection, MongoDB will still sort correctly but won't return the score value to the client.
db.articles
.find(
{ $text: { $search: 'mongodb performance index' } },
{ title: 1, score: { $meta: 'textScore' } }
)
.sort({ score: { $meta: 'textScore' } });
// Results ordered: most relevant firstHow textScore Is Calculated
MongoDB's textScore is based on a variant of TF-IDF (Term Frequency – Inverse Document Frequency) logic. Term frequency: a document with the search word appearing 10 times scores higher than one where it appears once. Field weights: matches in a field with weight 10 score 10× higher than matches in a weight-1 field. Index density: rarer words that appear in fewer documents contribute more to the score than very common words.
// Index with weights: title matches count more
db.articles.createIndex(
{ title: 'text', body: 'text' },
{ weights: { title: 10, body: 1 } }
);
// A document where 'mongodb' appears in the title
// scores 10x higher than one where it only appears in the body$meta in Aggregation Pipelines
In aggregation pipelines, use { $meta: 'textScore' } inside a $addFields or $project stage to attach the score, then pipe into $sort. Remember: the $match stage with $text must come first in the pipeline so MongoDB can compute the score before other stages transform the document stream.
db.articles.aggregate([
{ $match: { $text: { $search: 'nosql tutorial' } } },
{ $addFields: { score: { $meta: 'textScore' } } },
{ $sort: { score: -1 } },
{ $limit: 5 },
{ $project: { _id: 0, title: 1, score: 1 } }
]);Combining textScore Sort With Other Sorts
You can combine textScore sorting with other sort keys. For example, sort by relevance first, then by date as a tiebreaker. MongoDB processes sort keys left to right, so put textScore first to prioritise relevance. The additional sort keys only determine order among documents with equal textScore values.
db.articles
.find(
{ $text: { $search: 'mongodb' } },
{ title: 1, createdAt: 1, score: { $meta: 'textScore' } }
)
.sort({
score: { $meta: 'textScore' }, // relevance first
createdAt: -1 // then newest
});Filtering by Minimum Score
If you want to return only highly relevant documents, you can filter by a minimum textScore using the $meta expression inside a $match stage (in aggregation) after the text match. This is not possible with a direct find() filter; you need the aggregation pipeline to compute the score first and then filter on it.
db.articles.aggregate([
{ $match: { $text: { $search: 'mongodb nosql' } } },
{ $addFields: { score: { $meta: 'textScore' } } },
{ $match: { score: { $gte: 1.5 } } }, // only high-relevance docs
{ $sort: { score: -1 } },
{ $project: { title: 1, score: 1 } }
]);textScore Does Not Guarantee Absolute Values
The textScore values are relative within a query result set, not absolute or comparable across different queries or different collection states. A score of 2.5 today might become 3.1 tomorrow if you add more documents to the collection (changing term frequency calculations). Use textScore for sorting within a result set, not as a stored quality metric.
// Scores vary depending on collection content
// Useful for RANKING within a search result, not for thresholds
// Bad pattern:
const MIN_SCORE = 2.0; // this threshold will drift as data grows
// Better pattern:
// Return the top N results sorted by score
db.articles
.find({ $text: { $search: 'mongodb' } }, { score: { $meta: 'textScore' } })
.sort({ score: { $meta: 'textScore' } })
.limit(10);Pagination of Text Search Results
Standard skip()/limit() pagination works with text search, but it has the usual performance issue at deep offsets. Since results are relevance-ranked rather than ordered by a stable field, keyset pagination is not straightforward for text results. A common pattern is to use offset pagination for the first few pages (where most users stop) and consider Atlas Search for deeper, more consistent pagination at scale.
// Page 1 (skip 0)
db.articles
.find({ $text: { $search: 'mongodb' } }, { score: { $meta: 'textScore' } })
.sort({ score: { $meta: 'textScore' } })
.skip(0).limit(10);
// Page 2 (skip 10) - gets slower on large result sets
db.articles
.find({ $text: { $search: 'mongodb' } }, { score: { $meta: 'textScore' } })
.sort({ score: { $meta: 'textScore' } })
.skip(10).limit(10);textScore in Mongoose
When using Mongoose, you access textScore via the { meta: 'textScore' } option on a schema path or by using .select() with the score meta projection. Mongoose wraps the MongoDB driver's API, so the underlying concept is the same—you just need to know the Mongoose syntax for projecting and sorting by metadata.
// Mongoose text search with score projection
const results = await Article.find(
{ $text: { $search: 'mongodb nosql' } },
{ score: { $meta: 'textScore' } } // same $meta syntax
).sort({ score: { $meta: 'textScore' } });
console.log(results.map(r => ({ title: r.title, score: r.score })));When textScore Is Not Enough
Native text indexes work well for simple use cases, but they lack features like autocomplete, faceted search, synonyms, and custom ranking functions. When you need these capabilities, MongoDB Atlas Search (built on Apache Lucene) provides a much richer relevance scoring engine with BM25 scoring, boosting, and explain output for tuning relevance.
// Atlas Search provides richer scoring with the score option
// db.articles.aggregate([
// { $search: {
// text: { query: 'mongodb', path: 'title', score: { boost: { value: 3 } } },
// } },
// { $addFields: { score: { $meta: 'searchScore' } } },
// { $sort: { score: -1 } }
// ]);
// --> Use Atlas Search when textScore is insufficientQuick Check
Test your understanding of sorting by text score with $meta.
Lesson Recap
In this lesson you learned: textScore is a per-document relevance score computed during $text queries, { $meta: 'textScore' } projects and sorts by this score, and field weights and term frequency determine the score magnitude. Next up we cover text index limitations and when Atlas Search is the better choice.
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Mengurutkan Berdasarkan Skor Teks dengan $meta” gratis?
Ya — teks lengkap “Mengurutkan Berdasarkan Skor Teks dengan $meta” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus MongoDB Academy, upgrade ke CoddyKit PRO. Kursus MongoDB Academy mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “Mengurutkan Berdasarkan Skor Teks dengan $meta”?
Peserta didik akan memproyeksikan dan mengurutkan berdasarkan textScore untuk menampilkan dokumen yang paling relevan di bagian atas hasil. Kamu berlatih MongoDB Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.
Apakah aku perlu pengalaman untuk memulai MongoDB Academy?
Tidak diperlukan pengalaman sebelumnya. MongoDB Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.
Berapa lama pelajaran “Mengurutkan Berdasarkan Skor Teks dengan $meta” memakan waktu?
Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.
Bisakah aku menulis dan menjalankan kode dalam pelajaran MongoDB Academy ini?
Ya. Setiap pelajaran MongoDB Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.
Semua pelajaran dalam kursus ini
- Membuat Indeks Teks pada Bidang String
- Menjalankan Kueri $text dengan Frasa dan Negasi
- Mengurutkan Berdasarkan Skor Teks dengan $meta
- Keterbatasan Indeks Teks dan Kapan Menggunakan Atlas Search