Bootcamp i backendutvikling med Node.js · leksjon

CRUD-operasjoner med Mongoose

Implementer Create-, Read-, Update- og Delete-operasjoner ved hjelp av Mongoose-metoder for å håndtere dataene.

Leksjon 3 av 411 trinn

CRUD-operasjoner med Mongoose er en gratis leksjon i Bootcamp i backendutvikling med Node.js på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Bootcamp i backendutvikling med Node.js, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Bootcamp i backendutvikling med Node.js inneholder totalt 4 leksjoner.

Hva er CRUD?

CRUD står for Create, Read, Update og Delete. Dette er de fire grunnleggende operasjonene De utfører på data i nesten alle databaseapplikasjoner.

Å forstå CRUD er viktig for å bygge interaktive applikasjoner der brukere kan administrere informasjon.

Create: Legge til nye data.
Read: Hente eksisterende data.
Update: Endre eksisterende data.
Delete: Fjerne data.

Vår eksempelmodell i Mongoose

Før vi utfører CRUD-operasjoner, trenger vi en Mongoose-modell. Denne modellen definerer strukturen til dokumentene våre i MongoDB.

Vi bruker en enkel Book-modell i eksemplene våre:

const mongoose = require('mongoose');

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

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

Denne Book-modellen samhandler med en books-samling i databasen vår.

Opprette nye dokumenter

«Create»-operasjonen legger til nye dokumenter i MongoDB-samlingen. Med Mongoose kan De opprette en ny forekomst av modellen og deretter kalle .save()-metoden.

Alternativt kan De bruke Model.create() for en enklere fremgangsmåte.

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

Lese alle dokumenter

«Read»-operasjonen henter data. For å hente alle dokumentene fra en samling bruker De Model.find()-metoden uten argumenter.

Dette returnerer et Mongoose Query-objekt som De kan bruke med 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();

Finne bestemte dokumenter

For å finne dokumenter som samsvarer med bestemte kriterier sender De et spørringsobjekt til Model.find(). For ett enkelt dokument bruker De Model.findOne() eller Model.findById() hvis De har ID-en.

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

Oppdatere dokumenter enkelt

«Update»-operasjonen endrer eksisterende dokumenter. Mongoose tilbyr metoder som Model.findByIdAndUpdate() og Model.updateOne() til dette.

findByIdAndUpdate() er praktisk når et dokument skal oppdateres basert på den unike ID-en.

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

Manuell oppdatering og lagring

En annen måte å oppdatere på er først å finne dokumentet, endre egenskapene dets og deretter kalle .save()-metoden. Dette er nyttig når De må utføre logikk på dokumentet før det lagres.

Dette utløser Mongoose-mellomvare (som pre-save-hooks), i motsetning til `findByIdAndUpdate` som standard.

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

Slette dokumenter

«Delete»-operasjonen fjerner dokumenter fra samlingen Deres. Mongoose tilbyr metoder som Model.findByIdAndDelete() og Model.deleteOne() eller Model.deleteMany().

Bruk disse med forsiktighet, siden slettinger vanligvis er permanente!

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

Asynkrone operasjoner

Alle CRUD-operasjoner i Mongoose er asynkrone. Det betyr at de ikke blokkerer hovedtråden mens de venter på databasen.

Bruk alltid async/await eller Promises (.then()/.catch()) for å håndtere resultatene og eventuelle feil.

Riktig feilhåndtering sørger for at applikasjonen Deres er robust og brukervennlig.

CRUD-hurtigsjekk

Se på følgende Mongoose-modell og kodeutdrag:

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

Hva blir skrevet ut i konsollen?

Besvar den i den interaktive leksjonen

Sammendrag av CRUD-operasjoner

De har lært de viktigste CRUD-operasjonene med Mongoose!

Create: Bruk new Model().save() eller Model.create().
Read: Bruk Model.find(), Model.findOne() eller Model.findById().
Update: Bruk Model.findByIdAndUpdate(), eller finn og endre dokumentet før De bruker .save().
Delete: Bruk Model.findByIdAndDelete() eller Model.deleteOne().

Disse operasjonene utgjør grunnlaget for nesten alle datadrevne applikasjoner.

Gratis å komme i gang

Lær deg JavaScript med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 22
Leksjoner: 92

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «CRUD-operasjoner med Mongoose» gratis?

Ja – hele teksten i «CRUD-operasjoner med Mongoose» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Bootcamp i backendutvikling med Node.js-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Bootcamp i backendutvikling med Node.js inneholder totalt 4 leksjoner.

Hva lærer jeg i «CRUD-operasjoner med Mongoose»?

Implementer Create-, Read-, Update- og Delete-operasjoner ved hjelp av Mongoose-metoder for å håndtere dataene. Du øver på Bootcamp i backendutvikling med Node.js med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Bootcamp i backendutvikling med Node.js?

Ingen tidligere erfaring er nødvendig. Bootcamp i backendutvikling med Node.js på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «CRUD-operasjoner med Mongoose»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Bootcamp i backendutvikling med Node.js-leksjonen?

Ja. Alle Bootcamp i backendutvikling med Node.js-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Koble Node.js til MongoDB
Mongoose ODM for datamodellering
CRUD-operasjoner med Mongoose
Spørring og filtrering av data med Mongoose

← Tilbake til Bootcamp i backendutvikling med Node.js