Hvordan fungerer CRUD-operationer i MongoDB?

Question

Accepted Answer

**CRUD** (Create, Read, Update, Delete) operationer i MongoDB bruger metoder på collections. De arbejder med dokumenter og bruger en fleksibel, JSON-lignende query-syntaks — anderledes end SQL, men konceptuelt lignende.

## Create — indsæt dokumenter

```js
db.users.insertOne({ name: "Ann", age: 30 });          // insert one document
db.users.insertMany([                                   // insert multiple
  { name: "Bob", age: 25 },
  { name: "Carol", age: 28 }
]);
// each gets an auto-generated _id if not provided
```

## Read — søg i dokumenter

```js
db.users.find();                              // all documents
db.users.find({ age: 30 });                   // WHERE age = 30 (a query filter object)
db.users.find({ age: { $gt: 25 } });          // age > 25 ($gt operator)
db.users.findOne({ name: "Ann" });            // the first match
db.users.find({ active: true }, { name: 1 }); // projection — return only the name field
```

Søgninger bruger et **filter-dokument** (`{ field: value }`) der beskriver hvad der skal matches, med operatorer (`$gt`, `$lt`, `$in`, osv.) for betingelser. Projektion (`{ name: 1 }`) vælger hvilke felter der skal returneres.

## Update — modificer dokumenter

```js
// updateOne/updateMany with UPDATE OPERATORS ($set, $inc, etc.)
db.users.updateOne(
  { name: "Ann" },                  // filter — which document
  { $set: { age: 31 } }              // update — $set changes a field
);
db.users.updateMany(
  { active: false },
  { $set: { status: "inactive" } }   // update all matching
);
db.users.updateOne({ name: "Ann" }, { $inc: { loginCount: 1 } });  // increment
```

Opdateringer tager et **filter** (hvilke dokumenter) og et **update-dokument** med **operatorer** som `$set` (sæt et felt), `$inc` (inkrementér), `$push` (tilføj til et array) — du erstatter ikke hele dokumentet (medmindre det er meningen).

## Delete — fjern dokumenter

```js
db.users.deleteOne({ name: "Ann" });          // delete the first match
db.users.deleteMany({ active: false });        // delete all matching
```

## Hvorfor det betyder noget

CRUD-operationer er fundamentet for at arbejde med enhver database, så det er essentiel daglig viden at forstå hvordan de fungerer i MongoDB.

Operationerne — **indsættelse** af dokumenter (`insertOne`/`insertMany`), **søgning** med filter-dokumenter og operatorer (`find`/`findOne` med `{ field: value }` filtre, sammenligningsoperatorer som `$gt`, og projektioner til at vælge felter), **opdatering** med filtre og update-operatorer (`updateOne`/`updateMany` med `$set`, `$inc`, osv.), og **sletning** (`deleteOne`/`deleteMany`) — er hvordan applikationer opretter, læser, ændrer og fjerner data i MongoDB, hvilket er kernen i det meste databaseinteraktion.

At forstå Mongodbs særlige tilgang er vigtig: søgninger bruger et **filter-dokument** (et JSON-lignende objekt der beskriver hvad der skal matches, med operatorer) snarere end SQLs `WHERE`-syntaks, og opdateringer bruger **update-operatorer** (`$set` for at ændre felter, `$inc` for at inkrementere, `$push` for arrays) snarere end fuldstændig dokument-udskiftning — en anderledes men lærbar model.

Da CRUD er den fundamentale, konstante operation i enhver data-drevet applikation, og da Mongodbs CRUD-metoder, filter-dokument-queries og update-operatorer er hvordan du interagerer med databasen dag-til-dag, er det essentiel, must-know viden at forstå MongoDB CRUD-operationer — metoderne, filter/operator-query-syntaksen og update-operatorerne — for al MongoDB-udvikling, ækvivalenten med at kende SELECT/INSERT/UPDATE/DELETE for SQL og det praktiske fundament for at arbejde med databasen.