Bootcamp i backendutveckling med Node.js · Lektion

CRUD-operationer med Mongoose

Implementera Create-, Read-, Update- och Delete-operationer med Mongoose-metoder för att hantera era data.

Lektion 3 av 411 steg

CRUD-operationer med Mongoose är en gratis lektion i Bootcamp i backendutveckling med Node.js på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Bootcamp i backendutveckling med Node.js, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Bootcamp i backendutveckling med Node.js innehåller totalt 4 lektioner.

Vad är CRUD?

CRUD står för Create, Read, Update och Delete. Det är de fyra grundläggande operationerna som Ni utför på data i nästan alla databasapplikationer.

Att förstå CRUD är viktigt när Ni bygger interaktiva applikationer där användare kan hantera information.

Create: Lägga till nya data.
Read: Hämta befintliga data.
Update: Ändra befintliga data.
Delete: Ta bort data.

Vår Mongoose-exempelmodell

Innan vi utför CRUD-operationer behöver vi en Mongoose-modell. Denna modell definierar strukturen för våra dokument i MongoDB.

Vi använder en enkel Book-modell i våra exempel:

const mongoose = require('mongoose');

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

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

Denna Book-modell kommer att interagera med samlingen books i vår databas.

Skapa nya dokument

Operationen ”Create” lägger till nya dokument i Er MongoDB-samling. Med Mongoose kan Ni skapa en ny instans av Er modell och sedan anropa dess .save()-metod.

Alternativt kan Ni använda Model.create() för ett enklare tillvägagångssätt.

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

Läsa alla dokument

Operationen ”Read” hämtar data. Använd metoden Model.find() utan argument för att hämta alla dokument från en samling.

Detta returnerar ett Mongoose Query-objekt som Ni kan invänta 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();

Hitta specifika dokument

För att hitta dokument som motsvarar specifika kriterier skickar Ni ett frågeobjekt till Model.find(). För ett enskilt dokument använder Ni Model.findOne() eller Model.findById() om Ni har dess 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();

Uppdatera dokument enkelt

Operationen ”Update” ändrar befintliga dokument. Mongoose tillhandahåller metoder som Model.findByIdAndUpdate() och Model.updateOne() för detta.

findByIdAndUpdate() är praktisk när Ni vill uppdatera ett dokument med hjälp av dess unika 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();

Uppdatera och spara manuellt

Ett annat sätt att uppdatera är att först hitta dokumentet, ändra dess egenskaper och sedan anropa dess .save()-metod. Detta är användbart när Ni behöver utföra logik på dokumentet innan det sparas.

Det aktiverar Mongoose-middleware (som pre-save-hooks), till skillnad från `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();

Ta bort dokument

Operationen ”Delete” tar bort dokument från Er samling. Mongoose erbjuder metoder som Model.findByIdAndDelete() och Model.deleteOne() eller Model.deleteMany().

Använd dessa försiktigt, eftersom borttagningar vanligtvis är permanenta!

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

Asynkrona operationer

Alla Mongoose CRUD-operationer är asynkrona. Det innebär att de inte blockerar huvudtråden medan de väntar på databasen.

Använd alltid async/await eller Promises (.then()/.catch()) för att hantera deras resultat och eventuella fel.

Korrekt felhantering gör applikationen robust och användarvänlig.

Snabb kontroll av CRUD

Studera följande Mongoose-modell och kodavsnitt:

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

Vad kommer att loggas i konsolen?

Besvara frågan i den interaktiva lektionen

Sammanfattning av CRUD-operationer

Ni har lärt Er de viktigaste CRUD-operationerna med Mongoose!

Create: Använd new Model().save() eller Model.create().
Read: Använd Model.find(), Model.findOne() eller Model.findById().
Update: Använd Model.findByIdAndUpdate() eller hitta, ändra och sedan använda .save().
Delete: Använd Model.findByIdAndDelete() eller Model.deleteOne().

Dessa operationer utgör grunden för nästan alla datadrivna applikationer.

Gratis att börja

Lär dig JavaScript med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 22
Lektioner: 92

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”CRUD-operationer med Mongoose” gratis?

Ja – hela texten till ”CRUD-operationer med Mongoose” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Bootcamp i backendutveckling med Node.js, kan Ni uppgradera till CoddyKit PRO. Kursen i Bootcamp i backendutveckling med Node.js innehåller totalt 4 lektioner.

Vad lär jag mig i ”CRUD-operationer med Mongoose”?

Implementera Create-, Read-, Update- och Delete-operationer med Mongoose-metoder för att hantera era data. Ni övar på Bootcamp i backendutveckling med Node.js med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Bootcamp i backendutveckling med Node.js?

Du behöver inga förkunskaper. Utbildningen i Bootcamp i backendutveckling med Node.js på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”CRUD-operationer med Mongoose”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Bootcamp i backendutveckling med Node.js-lektionen?

Ja. Varje Bootcamp i backendutveckling med Node.js-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Bootcamp i backendutveckling med Node.js