MongoDB Academy · Pelajaran

Operator Logik: $and, $or, $nor, $not

Pelajar akan menggabungkan berbilang syarat dengan operator logik untuk menyatakan logik penapisan gabungan.

Pelajaran 2 daripada 413 langkah

Operator Logik: $and, $or, $nor, $not ialah pelajaran MongoDB Academy percuma di CoddyKit. Ini ialah pelajaran 2 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.

Mengapa Operator Logik Diperlukan

Kebanyakan penapis pertanyaan melibatkan syarat pada berbilang medan, dan tidak semuanya patut digabungkan dengan AND mudah. Kadangkala anda mahukan dokumen yang memenuhi mana-mana daripada beberapa syarat, atau mahu mengecualikan dokumen yang sepadan dengan sesuatu corak. Operator logik MongoDB—$and, $or, $nor dan $not—memberikan kawalan boolean penuh terhadap syarat penapis anda.

Memahami masa untuk menggunakan setiap operator—serta mengetahui pintasan AND tersirat—menjadikan pertanyaan anda lebih mudah dibaca dan lebih berprestasi.

AND Tersirat: Lalai

Apabila Anda menyenaraikan berbilang syarat medan dalam satu objek filter, MongoDB menggunakannya sebagai AND tersirat—semua syarat mestilah benar supaya dokumen sepadan. Ini ialah keadaan lalai dan paling biasa.

AND tersirat lebih ringkas dan sedikit lebih cekap berbanding pengendali $and yang dinyatakan secara jelas kerana MongoDB boleh mengoptimumkan syarat pada peringkat medan secara berasingan. Gunakan AND tersirat apabila syarat Anda menyasarkan medan yang berbeza tanpa kekaburan.

// Implicit AND - all three conditions must be true
db.users.find({
  age: { $gte: 18 },
  active: true,
  role: 'user'
});
// Equivalent to: age >= 18 AND active = true AND role = 'user'

// Same with explicit $and (more verbose, same result)
db.users.find({
  $and: [
    { age: { $gte: 18 } },
    { active: true },
    { role: 'user' }
  ]
});

Apabila Anda Memerlukan $and yang Dinyatakan Secara Jelas

$and yang dinyatakan secara jelas diperlukan dalam satu keadaan khusus: apabila Anda perlu menggunakan berbilang syarat pada medan yang sama dengan pengendali yang berbeza, dan Anda tidak dapat menyatakannya dalam satu objek (kerana objek JavaScript tidak boleh mempunyai kunci pendua).

Kes yang paling biasa ialah menggabungkan dua syarat $or yang kedua-duanya merujuk medan tersebut. Walau bagaimanapun, syarat julat pada satu medan ({ price: { $gte: 20, $lte: 100 } }) boleh digunakan dalam satu objek dengan baik—$and yang dinyatakan secara jelas hanya diperlukan apabila ungkapan tersebut tidak boleh digabungkan menjadi satu nilai medan.

// Explicit $and: two $or conditions that cannot be merged
db.products.find({
  $and: [
    { $or: [{ category: 'Electronics' }, { category: 'Computers' }] },
    { $or: [{ brand: 'Apple' }, { brand: 'Samsung' }] }
  ]
});
// (category is Electronics OR Computers)
// AND (brand is Apple OR Samsung)

// If you just wrote { $or: [...], $or: [...] }
// JS would only keep the last $or!

$or: Sekurang-kurangnya Satu Syarat

$or menerima tatasusunan syarat filter dan memadankan dokumen yang mempunyai sekurang-kurangnya satu syarat yang benar. Ia merupakan padanan MongoDB bagi kata kunci OR dalam SQL.

Gunakan $or apabila terdapat laluan alternatif untuk mendapatkan hasil yang sama—contohnya, mencari pengguna yang sama ada pentadbir atau aktif dalam tempoh 30 hari yang lalu. Satu perkara penting tentang prestasi: jika setiap syarat diindeks secara berasingan, MongoDB boleh menggunakan gabungan indeks untuk memenuhi pertanyaan—namun satu indeks kompaun yang merangkumi semua syarat selalunya lebih pantas.

// Find users who are admins OR have been recently active
const recentDate = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
db.users.find({
  $or: [
    { role: 'admin' },
    { lastLoginAt: { $gte: recentDate } }
  ]
});

// Find products on sale OR low in stock
db.products.find({
  $or: [
    { onSale: true },
    { stock: { $lt: 5 } }
  ]
});

$nor: Tiada Satu Pun Syarat

$nor memadankan dokumen yang tiada satu pun daripada syarat yang diberikan adalah benar—ia merupakan pelengkap kepada $or. Dokumen mestilah gagal memenuhi ALL syarat dalam tatasusunan $nor untuk dikembalikan.

$nor kurang biasa berbanding $or tetapi berguna untuk logik pengecualian: 'cari produk yang bukan dihentikan, bukan kehabisan stok dan bukan dalam kategori arkib.' Ia juga memadankan dokumen yang medan pertanyaannya tiada, kerana medan yang tiada tidak sepadan dengan sebarang syarat positif.

// Exclude multiple status values
db.orders.find({
  $nor: [
    { status: 'cancelled' },
    { status: 'refunded' },
    { status: 'archived' }
  ]
});
// Matches orders where status is NONE of the above
// (equivalent to status NOT IN [...])

// Could also write as:
db.orders.find({ status: { $nin: ['cancelled', 'refunded', 'archived'] } });

$not: Menafikan Satu Pengendali

$not membalikkan hasil ungkapan pengendali pada peringkat satu medan. Berbeza dengan $nor (yang menerima tatasusunan syarat filter penuh), $not membungkus satu pengendali atau ungkapan nalar: { price: { $not: { $gt: 100 } } }.

$not juga memadankan dokumen yang medannya tidak wujud. Ia sering berlebihan jika digunakan bersama $ne atau $nin, tetapi amat berguna untuk menafikan ungkapan biasa: { name: { $not: /^admin/i } }—tiada padanan $ne untuk corak ungkapan biasa.

// $not with a comparison operator
db.products.find({
  price: { $not: { $gt: 100 } }
});
// Matches: price <= 100 AND documents where price field is absent

// $not with a regex - negate a pattern
db.users.find({
  username: { $not: /^admin/i }
});
// Users whose username does NOT start with 'admin' (case-insensitive)

// Negating $in
db.items.find({
  status: { $not: { $in: ['draft', 'archived'] } }
});

Menggabungkan $and, $or dan $not

Pengendali logik boleh disarang untuk menyatakan logik boolean yang sangat kompleks. Bayangkan Anda sedang membina pepohon logik: syarat $and luar disambungkan pada peringkat teratas, manakala subungkapan $or menyatakan pilihan alternatif dalam satu cabang.

Pertanyaan boolean bersarang yang kompleks boleh sukar dibaca—pertimbangkan untuk memecahkannya menjadi pemboleh ubah JavaScript yang dinamakan atau membina objek filter secara teratur daripada input pengguna, bukannya menyarangnya sehingga lima peringkat dalam satu literal objek.

// Complex: (premium OR admin) AND (active) AND NOT (suspended)
db.users.find({
  $and: [
    { $or: [{ role: 'premium' }, { role: 'admin' }] },
    { active: true },
    { suspended: { $not: { $eq: true } } }
  ]
});

// Programmatic filter building (cleaner)
const filter = {};
if (roles.length > 0) filter['$or'] = roles.map(r => ({ role: r }));
if (activeOnly) filter.active = true;
db.users.find(filter);

Pertimbangan Prestasi $or

Pertanyaan $or mempunyai tingkah laku penggunaan indeks yang khusus. MongoDB menilai setiap cabang $or secara berasingan dan menggabungkan hasilnya:

Jika setiap cabang boleh menggunakan indeks, MongoDB melakukan gabungan indeks—cekap
Jika mana-mana cabang tidak boleh menggunakan indeks, MongoDB kembali kepada imbasan koleksi untuk cabang tersebut—berpotensi menjadi perlahan

Untuk prestasi terbaik, pastikan setiap cabang $or mempunyai indeks yang sepadan. Apabila syarat $or boleh ditulis semula sebagai $in pada medan yang sama ({ status: { $in: ['a','b'] } }), lakukan demikian—$in lebih cekap berbanding $or dua cabang pada medan yang sama.

// Inefficient: $or that prevents index use
db.products.find({
  $or: [
    { price: { $lt: 50 } },
    { description: { $regex: 'sale' } }  // Regex on unindexed field = COLLSCAN
  ]
});
// The regex branch causes a full scan for all matched documents

// Better: use $in when possible (same field, multiple values)
db.products.find({ category: { $in: ['A', 'B', 'C'] } });
// Single index lookup is more efficient than 3-branch $or

Pengendali Logik dalam Saluran Paip Agregasi

Dalam peringkat saluran paip agregasi seperti $match, pengendali logik yang sama berfungsi tepat seperti dalam find(). Letakkan $match bersama syarat logik Anda pada peringkat seawal mungkin dalam saluran paip untuk mengurangkan bilangan dokumen yang diproses oleh peringkat seterusnya.

Di dalam pengendali ungkapan saluran paip (seperti $project atau $addFields), pengendali logik mempunyai sintaks yang sedikit berbeza: { $and: [expr1, expr2] } sebagai pengendali ungkapan dan bukannya pengendali pertanyaan. Konteks pertanyaan ($match) dan ungkapan ($project) menggunakan nama pengendali yang sama tetapi sintaks yang berbeza.

// $match with logical operators in an aggregation pipeline
db.orders.aggregate([
  {
    $match: {
      $or: [
        { status: 'shipped' },
        { status: 'delivered' }
      ],
      createdAt: { $gte: new Date('2024-01-01') }
    }
  },
  { $group: { _id: '$customerId', totalOrders: { $sum: 1 } } }
]);

Corak Pembina Filter Praktikal

Dalam aplikasi sebenar, filter pertanyaan sering dibina secara dinamik daripada input pengguna (borang carian, parameter pertanyaan API). Bina objek filter secara teratur dan hanya tambahkan syarat apabila parameter diberikan—jangan tambahkan $or: [] dengan tatasusunan kosong kerana itu tidak akan memadankan apa-apa.

Sahkan dan bersihkan semua nilai yang diberikan pengguna sebelum memasukkannya ke dalam pertanyaan. Jangan sesekali menghantar rentetan pengguna mentah terus kepada $regex tanpa melindunginya—penyerang boleh menyuntik corak ungkapan biasa yang sangat perlahan secara melampau (serangan ReDoS).

function buildProductFilter(params) {
  const filter = {};

  if (params.categories && params.categories.length > 0) {
    filter.category = { $in: params.categories };
  }
  if (params.minPrice != null) {
    filter.price = { ...filter.price, $gte: params.minPrice };
  }
  if (params.maxPrice != null) {
    filter.price = { ...filter.price, $lte: params.maxPrice };
  }
  if (params.inStockOnly) {
    filter.stock = { $gt: 0 };
  }

  return filter;
}

const results = await db.collection('products')
  .find(buildProductFilter(req.query)).toArray();

Penilaian Pintasan dalam MongoDB

MongoDB menilai ungkapan pengendali logik tetapi TIDAK semestinya menggunakan penilaian pintasan seperti JavaScript. Perancang pertanyaan mungkin menyusun semula syarat demi kecekapan—contohnya, memindahkan syarat yang menggunakan indeks ke hadapan syarat yang tidak menggunakannya, tanpa mengira susunannya dalam dokumen pertanyaan.

Satu implikasi penting: dalam , jika cabang pertama menyebabkan imbasan koleksi penuh, keseluruhan pertanyaan mungkin mengimbas koleksi walaupun cabang kedua diindeks dengan cekap. Inilah sebabnya memastikan setiap cabang diindeks amat penting untuk prestasi. Gunakan explain() untuk mengesahkan bahawa pelan pelaksanaan sepadan dengan jangkaan Anda.

// MongoDB may reorder these conditions for efficiency:
db.products.find({
  : [
    { category: 'Electronics' },     // If indexed: fast point lookup
    { description: /wireless/i }     // Not indexed: slow scan
  ]
});
// Even though category (indexed) is listed first,
// if MongoDB cannot use index union, it may scan all docs.
// Always verify with .explain('executionStats')

Semakan Pantas

Uji pemahaman Anda tentang konsep MongoDB dan Pangkalan Data NoSQL daripada pelajaran ini.

Jawab dalam pelajaran interaktif

Imbas Kembali Pelajaran

Dalam pelajaran ini Anda telah mempelajari: AND tersirat ialah lalai apabila menyenaraikan berbilang medan dalam satu objek filter—$and yang dinyatakan secara jelas hanya diperlukan apabila Anda tidak dapat menyatakan syarat sebagai kunci unik (contohnya, dua blok $or), $or memadankan mana-mana satu syarat dan menggunakan gabungan indeks apabila setiap cabang diindeks, manakala $not membalikkan satu pengendali dan amat berguna untuk menafikan corak ungkapan biasa apabila $ne tidak terpakai. Seterusnya kita akan meneroka pengendali elemen seperti $exists dan $type untuk mengendalikan medan pilihan dan medan dengan jenis bercampur.

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 “Operator Logik: $and, $or, $nor, $not” percuma?

Ya — teks penuh “Operator Logik: $and, $or, $nor, $not” 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 “Operator Logik: $and, $or, $nor, $not”?

Pelajar akan menggabungkan berbilang syarat dengan operator logik untuk menyatakan logik penapisan gabungan. 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 2 daripada 4.

Berapa lamakah pelajaran “Operator Logik: $and, $or, $nor, $not” 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

Operator Perbandingan: $eq, $gt, $lt, $in
Operator Logik: $and, $or, $nor, $not
Operator Elemen dan Semakan Jenis
Pertanyaan Regex dan Padanan Corak

← Kembali ke MongoDB Academy