MongoDB Academy · Lektion

Sammenligningsoperatorer: $eq, $gt, $lt, $in

Brug sammenligningsoperatorer til at filtrere dokumenter efter numeriske intervaller, eksakte match og medlemskab af en liste.

Lektion 1 af 413 trin

Sammenligningsoperatorer: $eq, $gt, $lt, $in er en gratis MongoDB Academy-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i MongoDB Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. MongoDB Academy-kurset indeholder 4 lektioner i alt.

Ud over lighedsfiltre

Simple lighedsfiltre som { status: 'active' } er nyttige, men virkelige forespørgsler kræver flere nuancer. MongoDB har et omfattende sæt forespørgselsoperatorer med præfikset $, som udtrykker betingelser ud over simpel lighed. Med disse operatorer kan du filtrere efter numeriske intervaller, medlemskab af en liste, om værdier findes, og mønstermatchning.

Sammenligningsoperatorer er den mest anvendte kategori. De fungerer med alle sammenlignelige BSON-typer: tal, strenge (leksikografisk sammenligning), datoer og endda ObjectIds (kronologisk rækkefølge, fordi ObjectIds indeholder tidsstempler).

$eq: Eksplicit lighed

Operatoren $eq tester eksplicit for lighed: { age: { $eq: 30 } }. I de fleste tilfælde er den korte form { age: 30 } identisk og foretrækkes af hensyn til læsbarheden – $eq er primært nyttig, når operatoren skal bruges i et andet udtryk som $expr.

Der er én forskel: $eq i aggregationspipelineudtryk er påkrævet, når du sammenligner værdierne af to felter (f.eks. { $eq: ['$price', '$salePrice'] }). I almindelige find-filtre bør du bruge den korte lighedssyntaks, medmindre en bestemt kontekst kræver operatorsyntaksen.

// These two queries are equivalent in find()
db.users.find({ age: 30 });
db.users.find({ age: { $eq: 30 } });

// $eq is useful inside $expr for field-to-field comparison:
db.products.find({
  $expr: { $eq: ['$price', '$salePrice'] }
});
// Returns products where price equals salePrice

$gt og $gte: Større end

$gt (større end) og $gte (større end eller lig med) filtrerer dokumenter, hvor værdien i et felt overskrider en grænse. De fungerer med tal, datoer, strenge (leksikografisk rækkefølge) og ObjectIds.

Sammenligninger af datoer er særligt effektive: { createdAt: { $gte: new Date('2024-01-01') } } finder alle dokumenter, der er oprettet siden 1. januar 2024. Denne forespørgsel kan bruge et indeks på createdAt for O(log n)-ydeevne, hvilket gør forespørgsler efter datointervaller yderst effektive, selv i store samlinger.

// Numeric range
db.products.find({ price: { $gt: 100 } });
// price > 100

db.employees.find({ salary: { $gte: 50000 } });
// salary >= 50000

// Date comparison
db.orders.find({
  createdAt: { $gte: new Date('2024-01-01') }
});
// Orders placed since Jan 1, 2024

// String comparison (lexicographic)
db.users.find({ lastName: { $gte: 'M' } });
// Last names starting with M-Z

$lt og $lte: Mindre end

$lt (mindre end) og $lte (mindre end eller lig med) er komplementerne til $gt/$gte. Kombinér begge operatorer på det samme felt for at oprette en intervalforespørgsel – MongoDB anvender begge betingelser på det samme felt, svarende til SQL's BETWEEN.

Intervalforespørgsler på indekserede felter er meget effektive, fordi MongoDB kan springe til den nedre grænse i indekset og scanne frem til den øvre grænse, så kun de relevante poster berøres. Det er en af de primære grunde til at indeksere felter, du ofte filtrerer efter interval på.

// Price < 50
db.products.find({ price: { $lt: 50 } });

// Age <= 17 (minors)
db.users.find({ age: { $lte: 17 } });

// Range query: price between 20 and 100 (inclusive)
db.products.find({ price: { $gte: 20, $lte: 100 } });
// Equivalent SQL: WHERE price BETWEEN 20 AND 100

// Date range: orders placed last week
const weekAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
db.orders.find({ createdAt: { $gte: weekAgo, $lte: new Date() } });

$ne: Ikke lig med

$ne (ikke lig med) matcher dokumenter, hvor værdien i et felt ikke er lig med den angivne værdi. Den matcher også dokumenter, hvor feltet slet ikke findes – et manglende felt er nemlig implicit ikke lig med nogen værdi.

Vær forsigtig med $ne i store, ikke-indekserede samlinger: MongoDB kan typisk ikke bruge et indeks til effektivt at opfylde en negation og kan derfor falde tilbage til en samlingsscanning. I forespørgsler med omfattende filtrering bør du så vidt muligt foretrække positive betingelser ($eq, $in) frem for negative.

// Find orders that are not cancelled
db.orders.find({ status: { $ne: 'cancelled' } });

// Find users who have NOT set a display name
// ($ne also matches missing field)
db.users.find({ displayName: { $ne: null } });

// Caution: $ne on non-indexed field scans full collection
// Index the field if used frequently:
db.orders.createIndex({ status: 1 });
db.orders.find({ status: { $ne: 'cancelled' } }); // Uses index

$in: Match enhver værdi i en liste

$in matcher dokumenter, hvor værdien i et felt er lig med en hvilken som helst værdi i et angivet array. Det svarer i MongoDB til SQL's IN-udtryk. Det er langt mere kortfattet end at skrive flere $or-betingelser for det samme felt.

På et indekseret felt implementeres $in som flere punktopslag i indekstræet – ét pr. værdi i arrayet – hvilket er meget effektivt. For store lister (hundredvis af værdier) forringes ydeevnen, men til typiske anvendelser (5-20 værdier) er $in et fremragende valg.

// Find products in specific categories
db.products.find({
  category: { $in: ['Electronics', 'Computers', 'Peripherals'] }
});
// Equivalent SQL: WHERE category IN ('Electronics', 'Computers', 'Peripherals')

// Find orders with specific statuses
db.orders.find({
  status: { $in: ['pending', 'processing', 'shipped'] }
});

// $in on array field: matches if arrays share any element
db.products.find({
  tags: { $in: ['sale', 'clearance'] }
}); // Products with 'sale' OR 'clearance' in their tags array

$nin: Ikke i en liste

$nin (ikke i) er negationen af $in – den matcher dokumenter, hvor feltets værdi ikke findes i det angivne array (og matcher også dokumenter, hvor feltet mangler). Ligesom $ne kan den være mindre effektiv end $in, fordi den ofte kræver scanning af dokumenter.

En praktisk anvendelse er at udelukke et kendt sæt id'er. Hvis en bruger har blokeret bestemte andre brugere, kan du udelukke deres indhold: { authorId: { $nin: blockedUserIds } }. Hold udelukkelseslisten lille for at opnå den bedste ydeevne.

// Exclude archived and deleted statuses
db.tickets.find({
  status: { $nin: ['archived', 'deleted', 'spam'] }
});

// Exclude a user's own posts from their feed
const blockedIds = [ObjectId('...'), ObjectId('...')] ;
db.posts.find({
  authorId: { $nin: blockedIds }
}).sort({ createdAt: -1 }).limit(20);

Kombination af sammenligningsoperatorer

Du kan kombinere flere sammenligningsoperatorer på det samme felt eller på forskellige felter i en enkelt forespørgsel. Når operatorer optræder på det samme felt i ét objekt, fungerer de som et implicit AND – begge betingelser skal være sande. Når de gælder forskellige felter, skal begge betingelser også være sande.

Byg komplekse filtre ved at tænke på hvert felt separat og kombinere betingelserne. MongoDB evaluerer alle feltbetingelser samlet og bruger tilgængelige indekser for at minimere antallet af undersøgte dokumenter.

// Products priced between $20-$100, in stock, created this year
const thisYear = new Date('2024-01-01');
db.products.find({
  price: { $gte: 20, $lte: 100 },    // Range on price
  stock: { $gt: 0 },                  // In stock
  category: { $in: ['Electronics', 'Home'] },  // Category filter
  createdAt: { $gte: thisYear }       // Created this year
}).sort({ price: 1 });

Sammenligningsoperatorer på datoer

Sammenligning af datoer er blandt de mest almindelige anvendelser af sammenligningsoperatorer i virkelige applikationer. MongoDB's BSON-typen Date gemmer datoer som millisekunder på 64 bit, så alle sammenligningsoperatorer fungerer naturligt på datofelter.

Almindelige mønstre omfatter at finde poster, der er oprettet inden for de seneste N dage, filtrere aktive abonnementer, der udløber efter i dag, og udføre intervalforespørgsler for rapporteringsperioder. Opret altid Date-objekter i forespørgslen – sammenlign aldrig datoer som strenge, da leksikografisk sammenligning af strenge giver forkerte resultater for de fleste datoformater.

// Records created in the last 30 days
const thirtyDaysAgo = new Date();
thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
db.events.find({ createdAt: { $gte: thirtyDaysAgo } });

// Subscriptions that expire in the future (still active)
db.subscriptions.find({ expiresAt: { $gt: new Date() } });

// Orders placed on a specific day (date range for one day)
const startOfDay = new Date('2024-06-01T00:00:00Z');
const endOfDay = new Date('2024-06-01T23:59:59.999Z');
db.orders.find({ createdAt: { $gte: startOfDay, $lte: endOfDay } });

Ydeevne: Indekser og sammenligningsforespørgsler

Sammenligningsoperatorer har stor fordel af indekser. Et indeks på et numerisk felt omdanner en O(n)-scanning til O(log n + resultatstørrelse). Vigtige punkter:

Intervalforespørgsler ($gt, $lt) kan bruge et enkeltfeltsindeks til at navigere direkte til intervallets start
$in udfører flere punktopslag i indekset – ét pr. værdi
Negationsoperatorer ($ne, $nin) scanner ofte indekset i stedet for at bruge punktopslag, så de er mindre effektive
Brug explain('executionStats') til at kontrollere, at dine sammenligningsforespørgsler bruger IXSCAN og ikke COLLSCAN

// Verify range query uses index
db.products.find({ price: { $gte: 20, $lte: 100 } })
  .explain('executionStats');
// Look for: winningPlan.stage = 'IXSCAN'
// If COLLSCAN: add index with db.products.createIndex({ price: 1 })

// Create compound index for combined filter:
db.products.createIndex({ category: 1, price: 1 });
// Supports: { category: 'Electronics', price: { $gte: 50 } }

Brug af sammenligningsoperatorer med aggregation

Sammenligningsoperatorer optræder i to sammenhænge: som forespørgselsoperatorer i find()-filtre (med syntaksen { field: { : value } }) og som udtryksoperatorer i aggregationspipelinen - og -stadierne (med en anden syntaks: { : ['', value] }).

I returnerer udtryksoperatorer en boolesk værdi eller en beregnet værdi. Du kan f.eks. tilføje et beregnet felt isExpensive, der er sandt, når prisen overstiger 100: { : { isExpensive: { : ['', 100] } } }. Stadiet bruger samme forespørgselssyntaks som find().

// Comparison in aggregation pipeline:
db.products.aggregate([
  //  uses same syntax as find()
  { : { price: { : 20, : 100 } } },
  //  uses expression operator syntax:
  {
    : {
      isExpensive: { : ['', 80] },      // Returns boolean
      discountedPrice: { : ['', 0.9] }  // Computes value
    }
  }
]);

Hurtigt tjek

Test din forståelse af begreberne MongoDB og NoSQL-databaser fra denne lektion.

Besvar den i den interaktive lektion

Opsummering af lektionen

I denne lektion lærte du, at $gt/$gte/$lt/$lte opretter intervalbetingelser for tal, datoer og strenge og fungerer sammen med indekser ved O(log n)-intervalscanninger, at $in matcher enhver værdi fra en liste og er betydeligt mere læsbar og effektiv end flere $or-lighedsbetingelser på det samme felt, og at $ne/$nin er negationsoperatorer, der matcher alt uden for den angivne værdi eller liste, men er mindre effektive med indekser end deres positive modstykker. Dernæst udforsker vi logiske operatorer – $and, $or, $nor og $not – til at kombinere betingelser på tværs af forskellige felter.

Gratis at komme i gang

Lær JavaScript med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 30
Lektioner: 120

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Sammenligningsoperatorer: $eq, $gt, $lt, $in” gratis?

Ja — hele teksten til “Sammenligningsoperatorer: $eq, $gt, $lt, $in” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af MongoDB Academy-kurset, skal du opgradere til CoddyKit PRO. MongoDB Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Sammenligningsoperatorer: $eq, $gt, $lt, $in”?

Brug sammenligningsoperatorer til at filtrere dokumenter efter numeriske intervaller, eksakte match og medlemskab af en liste. Du øver dig i MongoDB Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på MongoDB Academy?

Der kræves ingen tidligere erfaring. MongoDB Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.

Hvor lang tid tager lektionen “Sammenligningsoperatorer: $eq, $gt, $lt, $in”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne MongoDB Academy-lektion?

Ja. Alle MongoDB Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Sammenligningsoperatorer: $eq, $gt, $lt, $in
Logiske operatorer: $and, $or, $nor, $not
Elementoperatorer og typekontrol
Regex-forespørgsler og mønstermatch

← Tilbage til MongoDB Academy