Node.js Backend Development Bootcamp · Lektion

CRUD-Operationen mit Mongoose

Implementieren Sie Create-, Read-, Update- und Delete-Operationen mit Mongoose-Methoden zur Verwaltung Ihrer Daten.

CRUD-Operationen mit Mongoose ist eine kostenlose Node.js Backend Development Bootcamp-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Node.js Backend Development Bootcamp-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Node.js Backend Development Bootcamp-Kurs umfasst insgesamt 4 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

What is CRUD?

CRUD stands for Create, Read, Update, and Delete. These are the four fundamental operations you perform on data in almost any database application.

Understanding CRUD is key to building interactive applications where users can manage information.

Create: Adding new data.
Read: Retrieving existing data.
Update: Modifying existing data.
Delete: Removing data.

Our Sample Mongoose Model

Before we perform CRUD operations, we need a Mongoose model. This model defines the structure of our documents in MongoDB.

We'll use a simple Book model for our examples:

const mongoose = require('mongoose');

const bookSchema = new mongoose.Schema({
  title: String,
  author: String,
  year: Number
});

const Book = mongoose.model('Book', bookSchema);

This Book model will interact with a books collection in our database.

Creating New Documents

The "Create" operation adds new documents to your MongoDB collection. With Mongoose, you can create a new instance of your model and then call its .save() method.

Alternatively, use Model.create() for a simpler approach.

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();

Reading All Documents

The "Read" operation retrieves data. To get all documents from a collection, use the Model.find() method without any arguments.

This returns a Mongoose Query object that you can await.

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();

Finding Specific Documents

To find documents that match specific criteria, pass a query object to Model.find(). For a single document, use Model.findOne() or Model.findById() if you have its 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 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();

Updating Documents Easily

The "Update" operation modifies existing documents. Mongoose provides methods like Model.findByIdAndUpdate() and Model.updateOne() for this.

findByIdAndUpdate() is convenient for updating a document by its unique 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();

Manual Update & Save

Another way to update is to first find the document, modify its properties, and then call its .save() method. This is useful when you need to perform logic on the document before saving.

It triggers Mongoose middleware (like pre-save hooks) unlike `findByIdAndUpdate` by default.

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();

Deleting Documents

The "Delete" operation removes documents from your collection. Mongoose offers methods like Model.findByIdAndDelete() and Model.deleteOne() or Model.deleteMany().

Use these carefully as deletions are usually 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();

Asynchronous Operations

All Mongoose CRUD operations are asynchronous. This means they don't block the main thread while waiting for the database.

Always use async/await or Promises (.then()/.catch()) to handle their results and potential errors.

Proper error handling ensures your application is robust and user-friendly.

CRUD Quick Check

Consider the following Mongoose model and code snippet:

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();

What will be logged to the console?

CRUD Operations Summary

You've learned the essential CRUD operations with Mongoose!

Create: Use new Model().save() or Model.create().
Read: Use Model.find(), Model.findOne(), or Model.findById().
Update: Use Model.findByIdAndUpdate() or find, modify, then .save().
Delete: Use Model.findByIdAndDelete() or Model.deleteOne().

These operations form the backbone of almost any data-driven application.

Häufig gestellte Fragen

Ist die Lektion „CRUD-Operationen mit Mongoose“ kostenlos?

Ja — der vollständige Text von „CRUD-Operationen mit Mongoose“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Node.js Backend Development Bootcamp-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Node.js Backend Development Bootcamp-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „CRUD-Operationen mit Mongoose“?

Implementieren Sie Create-, Read-, Update- und Delete-Operationen mit Mongoose-Methoden zur Verwaltung Ihrer Daten. Du übst Node.js Backend Development Bootcamp mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Node.js Backend Development Bootcamp zu starten?

Keine Vorkenntnisse erforderlich. Node.js Backend Development Bootcamp auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „CRUD-Operationen mit Mongoose“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Node.js Backend Development Bootcamp-Lektion Code schreiben und ausführen?

Ja. Jede Node.js Backend Development Bootcamp-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Node.js Backend Development Bootcamp