0Pricing
Node.js Backend Development Bootcamp · Ders

Mongoose ile CRUD İşlemleri

Verilerinizi yönetmek için Mongoose yöntemlerini kullanarak oluşturma, okuma, güncelleme ve silme işlemlerini uygulayın.

Mongoose ile CRUD İşlemleri, CoddyKit'te ücretsiz bir Node.js Backend Development Bootcamp dersidir. Bu, 4 dersinin 3. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Node.js Backend Development Bootcamp öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Node.js Backend Development Bootcamp kursu toplamda 4 dersten oluşur.

Bu dersin bazı bölümleri henüz çevrilmemiş olup İngilizce olarak gösterilmektedir.

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.

Sıkça Sorulan Sorular

“Mongoose ile CRUD İşlemleri” dersi ücretsiz mi?

Evet — “Mongoose ile CRUD İşlemleri” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Node.js Backend Development Bootcamp kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Node.js Backend Development Bootcamp kursu toplamda 4 dersten oluşur.

“Mongoose ile CRUD İşlemleri” dersinde ne öğreneceğim?

Verilerinizi yönetmek için Mongoose yöntemlerini kullanarak oluşturma, okuma, güncelleme ve silme işlemlerini uygulayın. Node.js Backend Development Bootcamp ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Node.js Backend Development Bootcamp öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Node.js Backend Development Bootcamp, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 3. dersidir.

“Mongoose ile CRUD İşlemleri” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Node.js Backend Development Bootcamp dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Node.js Backend Development Bootcamp dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

  1. Node.js'i MongoDB'ye Bağlama
  2. Veri Modellemede Mongoose ODM
  3. Mongoose ile CRUD İşlemleri
  4. Mongoose ile Veri Sorgulama ve Filtreleme
← Node.js Backend Development Bootcamp Sayfasına Dön