Hur fungerar CRUD-operationer i MongoDB?

Question

Accepted Answer

**CRUD** (Create, Read, Update, Delete) är operationer i MongoDB som använder metoder på collections. De arbetar med dokument och använder en flexibel, JSON-liknande frågesyntax — annorlunda än SQL men konceptuellt likartad.

## Create — infoga dokument

```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 — fråga dokument

```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
```

Frågor använder ett **filterdokument** (`{ field: value }`) som beskriver vad som ska matchas, med operatorer (`$gt`, `$lt`, `$in`, osv.) för villkor. Projektion (`{ name: 1 }`) väljer vilka fält som ska returneras.

## Update — modifiera dokument

```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
```

Uppdateringar tar ett **filter** (vilka dokument) och ett **uppdateringsdokument** som använder **operatorer** som `$set` (sätt ett fält), `$inc` (öka), `$push` (lägg till i en array) — du ersätter inte hela dokumentet (om inte avsiktligt).

## Delete — ta bort dokument

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

## Varför det är viktigt

CRUD-operationer är grunden för att arbeta med någon databas, så att förstå hur de fungerar i MongoDB är väsentlig kunskap för att använda det dagligen.

Operationerna — **infoga** dokument (`insertOne`/`insertMany`), **fråga** med filterdokument och operatorer (`find`/`findOne` med `{ field: value }`-filter, jämförelsesoperatorer som `$gt` och projektioner för att välja fält), **uppdatera** med filter och uppdateringsoperatorer (`updateOne`/`updateMany` med `$set`, `$inc`, osv.) och **ta bort** (`deleteOne`/`deleteMany`) — är hur applikationer skapar, läser, ändrar och tar bort data i MongoDB, vilket är kärnan i de flesta databasinteraktioner.

Att förstå MongoDBs karakteristiska tillvagagångssätt är viktigt: frågor använder ett **filterdokument** (ett JSON-liknande objekt som beskriver vad som ska matchas, med operatorer) snarare än SQLs `WHERE`-syntax, och uppdateringar använder **uppdateringsoperatorer** (`$set` för att ändra fält, `$inc` för att öka, `$push` för arrays) snarare än full-dokumentersättning — en annorlunda men lätt att lära sig modell.

Since CRUD är den grundläggande, konstanta operationen i alla datadrivna applikationer, och eftersom MongoDBs CRUD-metoder, filter-dokument-frågors och uppdateringsoperatorer är hur du interagerar med databasen dagligen, är det att förstå MongoDB CRUD-operationer — metoderna, filter/operatör-frågesyntaxen och uppdateringsoperatorerna — väsentlig, måste-kunnas kunskap för all MongoDB-utveckling, motsvarigheten till att kunna SELECT/INSERT/UPDATE/DELETE för SQL och den praktiska grunden för att arbeta med databasen.