CRUD-bewerkingen met Mongoose
Implementeer Create-, Read-, Update- en Delete-bewerkingen met Mongoose-methoden om uw gegevens te beheren.
CRUD-bewerkingen met Mongoose is een gratis Bootcamp backendontwikkeling met Node.js-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Bootcamp backendontwikkeling met Node.js. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Bootcamp backendontwikkeling met Node.js bevat in totaal 4 lessen.
Wat is CRUD?
CRUD staat voor Create, Read, Update en Delete. Dit zijn de vier fundamentele bewerkingen die je uitvoert op gegevens in vrijwel elke databasetoepassing.
Inzicht in CRUD is essentieel voor het bouwen van interactieve toepassingen waarin gebruikers gegevens kunnen beheren.
- Create: Nieuwe gegevens toevoegen.
- Read: Bestaande gegevens ophalen.
- Update: Bestaande gegevens wijzigen.
- Delete: Gegevens verwijderen.
Ons voorbeeldmodel voor Mongoose
Voordat we CRUD-bewerkingen uitvoeren, hebben we een Mongoose-model nodig. Dit model definieert de structuur van onze documenten in MongoDB.
Voor onze voorbeelden gebruiken we een eenvoudig Book-model:
const mongoose = require('mongoose');
const bookSchema = new mongoose.Schema({
title: String,
author: String,
year: Number
});
const Book = mongoose.model('Book', bookSchema);Dit Book-model werkt met een verzameling books in onze database.
Nieuwe documenten maken
Met de bewerking "Create" voeg je nieuwe documenten toe aan je MongoDB-verzameling. Met Mongoose kun je een nieuw exemplaar van je model maken en vervolgens de methode .save() aanroepen.
Je kunt ook Model.create() gebruiken voor een eenvoudigere aanpak.
const mongoose = require('mongoose');
const bookSchema = new mongoose.Schema({
title: String,
author: String,
year: Number
});
const Book = mongoose.model('Book', bookSchema);
async function main() {
await mongoose.connect('mongodb://localhost:27017/coddykit_db');
console.log('Connected to MongoDB!');
try {
const newBook = new Book({
title: 'The Great Adventure',
author: 'A. Explorer',
year: 2023
});
await newBook.save();
console.log('Book created:', newBook.title);
const anotherBook = await Book.create({
title: 'Node.js Handbook',
author: 'J. Developer',
year: 2022
});
console.log('Book created using create():', anotherBook.title);
} catch (error) {
console.error('Error creating book:', error);
} finally {
await mongoose.disconnect();
console.log('Disconnected from MongoDB.');
}
}
main();Alle documenten lezen
Met de bewerking "Read" haal je gegevens op. Gebruik de methode Model.find() zonder argumenten om alle documenten uit een verzameling op te halen.
Dit retourneert een Mongoose Query-object waarop je await kunt gebruiken.
const mongoose = require('mongoose');
const bookSchema = new mongoose.Schema({
title: String,
author: String,
year: Number
});
const Book = mongoose.model('Book', bookSchema);
async function main() {
await mongoose.connect('mongodb://localhost:27017/coddykit_db');
console.log('Connected to MongoDB!');
try {
// Ensure there are some books to read
await Book.deleteMany({}); // Clear existing for clean run
await Book.create([
{ title: 'Book One', author: 'Author A', year: 2000 },
{ title: 'Book Two', author: 'Author B', year: 2010 }
]);
const allBooks = await Book.find();
console.log('All Books:');
allBooks.forEach(book => console.log(`- ${book.title} by ${book.author}`));
} catch (error) {
console.error('Error reading books:', error);
} finally {
await mongoose.disconnect();
console.log('Disconnected from MongoDB.');
}
}
main();Specifieke documenten vinden
Als je documenten wilt vinden die aan specifieke criteria voldoen, geef je een queryobject door aan Model.find(). Gebruik voor één document Model.findOne() of Model.findById() als je de ID ervan hebt.
const mongoose = require('mongoose');
const bookSchema = new mongoose.Schema({
title: String,
author: String,
year: Number
});
const Book = mongoose.model('Book', bookSchema);
async function main() {
await mongoose.connect('mongodb://localhost:27017/coddykit_db');
console.log('Connected to MongoDB!');
try {
await Book.deleteMany({});
const book1 = await Book.create({ title: 'Specific Book', author: 'Jane Doe', year: 2015 });
await Book.create({ title: 'Another Book', author: 'John Smith', year: 2018 });
const foundBookById = await Book.findById(book1._id);
console.log('Found by ID:', foundBookById.title);
const foundBookByTitle = await Book.findOne({ title: 'Another Book' });
console.log('Found by title:', foundBookByTitle.title);
const booksByAuthor = await Book.find({ author: 'Jane Doe' });
console.log('Books by Jane Doe:', booksByAuthor.length);
} catch (error) {
console.error('Error finding specific books:', error);
} finally {
await mongoose.disconnect();
console.log('Disconnected from MongoDB.');
}
}
main();Documenten eenvoudig bijwerken
Met de bewerking "Update" wijzig je bestaande documenten. Mongoose biedt hiervoor methoden zoals Model.findByIdAndUpdate() en Model.updateOne().
findByIdAndUpdate() is handig om een document bij te werken op basis van de unieke ID.
const mongoose = require('mongoose');
const bookSchema = new mongoose.Schema({
title: String,
author: String,
year: Number
});
const Book = mongoose.model('Book', bookSchema);
async function main() {
await mongoose.connect('mongodb://localhost:27017/coddykit_db');
console.log('Connected to MongoDB!');
try {
await Book.deleteMany({});
const createdBook = await Book.create({ title: 'Old Title', author: 'Original Author', year: 2000 });
console.log('Original Book:', createdBook.title);
const updatedBook = await Book.findByIdAndUpdate(
createdBook._id,
{ title: 'New & Improved Title', year: 2024 },
{ new: true } // Return the updated document
);
console.log('Updated Book:', updatedBook.title, 'Year:', updatedBook.year);
} catch (error) {
console.error('Error updating book:', error);
} finally {
await mongoose.disconnect();
console.log('Disconnected from MongoDB.');
}
}
main();Handmatig bijwerken en opslaan
Een andere manier om bij te werken is eerst het document te vinden, de eigenschappen ervan te wijzigen en vervolgens de methode .save() aan te roepen. Dit is handig als je logica op het document moet uitvoeren voordat je het opslaat.
In tegenstelling tot `findByIdAndUpdate` activeert dit standaard Mongoose-middleware (zoals hooks vóór het opslaan).
const mongoose = require('mongoose');
const bookSchema = new mongoose.Schema({
title: String,
author: String,
year: Number
});
const Book = mongoose.model('Book', bookSchema);
async function main() {
await mongoose.connect('mongodb://localhost:27017/coddykit_db');
console.log('Connected to MongoDB!');
try {
await Book.deleteMany({});
const createdBook = await Book.create({ title: 'To Be Modified', author: 'Someone', year: 2010 });
console.log('Original Book:', createdBook.title);
const bookToModify = await Book.findById(createdBook._id);
if (bookToModify) {
bookToModify.title = 'Modified Title with Save';
bookToModify.year = 2011;
await bookToModify.save();
console.log('Modified Book:', bookToModify.title, 'Year:', bookToModify.year);
}
} catch (error) {
console.error('Error modifying and saving book:', error);
} finally {
await mongoose.disconnect();
console.log('Disconnected from MongoDB.');
}
}
main();Documenten verwijderen
Met de bewerking "Delete" verwijder je documenten uit je verzameling. Mongoose biedt hiervoor methoden zoals Model.findByIdAndDelete(), Model.deleteOne() en Model.deleteMany().
Gebruik deze zorgvuldig, want verwijderingen zijn meestal permanent!
const mongoose = require('mongoose');
const bookSchema = new mongoose.Schema({
title: String,
author: String,
year: Number
});
const Book = mongoose.model('Book', bookSchema);
async function main() {
await mongoose.connect('mongodb://localhost:27017/coddykit_db');
console.log('Connected to MongoDB!');
try {
await Book.deleteMany({});
const bookToDelete = await Book.create({ title: 'Ephemeral Book', author: 'Ghost', year: 2020 });
await Book.create({ title: 'Another One', author: 'Someone Else', year: 2021 });
console.log('Books before delete:', (await Book.find()).length);
await Book.findByIdAndDelete(bookToDelete._id);
console.log('Book deleted by ID.');
console.log('Books after delete:', (await Book.find()).length);
await Book.deleteOne({ title: 'Another One' });
console.log('Another book deleted by criteria.');
console.log('Books after second delete:', (await Book.find()).length);
} catch (error) {
console.error('Error deleting book:', error);
} finally {
await mongoose.disconnect();
console.log('Disconnected from MongoDB.');
}
}
main();Asynchrone bewerkingen
Alle Mongoose-CRUD-bewerkingen zijn asynchroon. Dit betekent dat ze de hoofdthread niet blokkeren terwijl ze op de database wachten.
Gebruik altijd async/await of Promises (.then()/.catch()) om hun resultaten en mogelijke fouten af te handelen.
Een goede foutafhandeling zorgt ervoor dat je toepassing robuust en gebruiksvriendelijk is.
Korte CRUD-controle
Bekijk het volgende Mongoose-model en codefragment:
const userSchema = new mongoose.Schema({
username: String,
email: String
});
const User = mongoose.model('User', userSchema);
// ... connection established ...
async function performAction() {
const newUser = await User.create({ username: 'coder', email: 'coder@example.com' });
newUser.username = 'pro_coder';
await newUser.save();
console.log(newUser.username);
}
performAction();Wat wordt er naar de console gelogd?
Samenvatting van CRUD-bewerkingen
Je hebt de belangrijkste CRUD-bewerkingen met Mongoose geleerd!
- Create: Gebruik
new Model().save()ofModel.create(). - Read: Gebruik
Model.find(),Model.findOne()ofModel.findById(). - Update: Gebruik
Model.findByIdAndUpdate(), of zoek het document, wijzig het en gebruik vervolgens.save(). - Delete: Gebruik
Model.findByIdAndDelete()ofModel.deleteOne().
Deze bewerkingen vormen de basis van vrijwel elke gegevensgestuurde toepassing.
Leer JavaScript met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 22
- Lessen
- 92
Veelgestelde vragen
Is de les “CRUD-bewerkingen met Mongoose” gratis?
Ja — de volledige tekst van “CRUD-bewerkingen met Mongoose” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Bootcamp backendontwikkeling met Node.js wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Bootcamp backendontwikkeling met Node.js bevat in totaal 4 lessen.
Wat leer ik in “CRUD-bewerkingen met Mongoose”?
Implementeer Create-, Read-, Update- en Delete-bewerkingen met Mongoose-methoden om uw gegevens te beheren. Je oefent met Bootcamp backendontwikkeling met Node.js door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Bootcamp backendontwikkeling met Node.js te beginnen?
Ervaring vooraf is niet nodig. Bootcamp backendontwikkeling met Node.js op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.
Hoe lang duurt de les “CRUD-bewerkingen met Mongoose”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Bootcamp backendontwikkeling met Node.js?
Ja. Elke les over Bootcamp backendontwikkeling met Node.js bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Node.js verbinden met MongoDB
- Mongoose ODM voor datamodellering
- CRUD-bewerkingen met Mongoose
- Gegevens opvragen en filteren met Mongoose