Node.js-taustakehityksen bootcamp · Oppitunti

CRUD-toiminnot Mongoose-ohjelmistolla

Toteutatte Create-, Read-, Update- ja Delete-toiminnot Mongoose-metodeilla tietojen hallintaa varten.

Oppitunti 3/411 vaihetta

CRUD-toiminnot Mongoose-ohjelmistolla on ilmainen Node.js-taustakehityksen bootcamp-oppitunti CoddyKitissä. Tämä on oppitunti 3/4. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu Node.js-taustakehityksen bootcamp-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Node.js-taustakehityksen bootcamp-kurssilla on yhteensä 4 oppituntia.

Mitä CRUD tarkoittaa?

CRUD tulee sanoista Create, Read, Update ja Delete. Nämä ovat neljä perustavanlaatuista toimintoa, joita käytetään tietojen käsittelyyn lähes kaikissa tietokantasovelluksissa.

CRUD-toimintojen ymmärtäminen on tärkeää interaktiivisten sovellusten rakentamisessa, sillä niiden avulla käyttäjät voivat hallita tietoja.

Create: Uusien tietojen lisääminen.
Read: Olemassa olevien tietojen hakeminen.
Update: Olemassa olevien tietojen muokkaaminen.
Delete: Tietojen poistaminen.

Esimerkkimme Mongoose-malli

Ennen CRUD-toimintojen suorittamista tarvitsemme Mongoose-mallin. Tämä malli määrittää MongoDB-dokumenttiemme rakenteen.

Käytämme esimerkeissä yksinkertaista Book-mallia:

const mongoose = require('mongoose');

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

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

Tämä Book-malli käsittelee tietokantamme books-kokoelmaa.

Uusien dokumenttien luominen

"Create"-toiminto lisää uusia dokumentteja MongoDB-kokoelmaan. Mongoosea käyttäen voit luoda uuden mallin ilmentymän ja kutsua sen jälkeen sen .save()-metodia.

Vaihtoehtoisesti voit käyttää yksinkertaisempaa tapaa, Model.create()-metodia.

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

Kaikkien dokumenttien lukeminen

"Read"-toiminto hakee tietoja. Voit hakea kaikki kokoelman dokumentit käyttämällä Model.find()-metodia ilman argumentteja.

Tämä palauttaa Mongoose Query -olion, jota voit odottaa await-avainsanalla.

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

Tiettyjen dokumenttien etsiminen

Voit hakea tiettyjä ehtoja vastaavat dokumentit välittämällä kyselyolion Model.find()-metodille. Jos tarvitset yhden dokumentin, käytä Model.findOne()-metodia tai Model.findById()-metodia, jos sinulla on dokumentin tunniste.

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

Dokumenttien helppo päivittäminen

"Update"-toiminto muokkaa olemassa olevia dokumentteja. Mongoose tarjoaa tähän metodeja, kuten Model.findByIdAndUpdate() ja Model.updateOne().

findByIdAndUpdate() on kätevä tapa päivittää dokumentti sen yksilöllisen tunnisteen perusteella.

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

Manuaalinen päivitys ja tallennus

Toinen tapa päivittää dokumenttia on etsiä se ensin, muokata sen ominaisuuksia ja kutsua sitten sen .save()-metodia. Tämä on hyödyllistä, kun dokumentille on tehtävä käsittelyä ennen tallentamista.

Se käynnistää Mongoose-väliohjelmiston (kuten tallennusta edeltävät hookit), toisin kuin `findByIdAndUpdate` oletusarvoisesti.

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

Dokumenttien poistaminen

"Delete"-toiminto poistaa dokumentteja kokoelmasta. Mongoose tarjoaa tähän metodeja, kuten Model.findByIdAndDelete(), Model.deleteOne() ja Model.deleteMany().

Käyttäkää näitä harkiten, sillä poistot ovat yleensä pysyviä!

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

Asynkroniset toiminnot

Kaikki Mongoose CRUD -toiminnot ovat asynkronisia. Tämä tarkoittaa, etteivät ne estä pääsäiettä tietokantaa odotettaessa.

Käyttäkää aina async/await-rakennetta tai Promiseja (.then()/.catch()) niiden tulosten ja mahdollisten virheiden käsittelyyn.

Asianmukainen virheenkäsittely tekee sovelluksesta luotettavan ja käyttäjäystävällisen.

CRUD-pikatarkistus

Tarkastelkaa seuraavaa Mongoose-mallia ja koodikatkelmaa:

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

Mitä konsoliin tulostetaan?

Vastaa interaktiivisessa oppitunnissa

CRUD-toimintojen yhteenveto

Olette oppineet Mongoose-sovellusten keskeiset CRUD-toiminnot!

Create: Käytä new Model().save()- tai Model.create()-metodia.
Read: Käytä Model.find()-, Model.findOne()- tai Model.findById()-metodia.
Update: Käytä Model.findByIdAndUpdate()-metodia tai etsi dokumentti, muokkaa sitä ja kutsu sitten .save()-metodia.
Delete: Käytä Model.findByIdAndDelete()- tai Model.deleteOne()-metodia.

Nämä toiminnot muodostavat lähes kaikkien tietopohjaisten sovellusten perustan.

Aloita maksutta

Opi JavaScript tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 22
Oppitunnit: 92

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”CRUD-toiminnot Mongoose-ohjelmistolla” ilmainen?

Kyllä – oppitunnin ”CRUD-toiminnot Mongoose-ohjelmistolla” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko Node.js-taustakehityksen bootcamp-kurssin, päivitä CoddyKit PROhon. Node.js-taustakehityksen bootcamp-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”CRUD-toiminnot Mongoose-ohjelmistolla”?

Toteutatte Create-, Read-, Update- ja Delete-toiminnot Mongoose-metodeilla tietojen hallintaa varten. Harjoittelet Node.js-taustakehityksen bootcamp-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Node.js-taustakehityksen bootcamp-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Node.js-taustakehityksen bootcamp-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 3/4.

Kuinka kauan ”CRUD-toiminnot Mongoose-ohjelmistolla”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Node.js-taustakehityksen bootcamp-oppitunnilla?

Kyllä. Jokainen Node.js-taustakehityksen bootcamp-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

Node.js:n yhdistäminen MongoDB:hen
Mongoose ODM tietomallinnukseen
CRUD-toiminnot Mongoose-ohjelmistolla
Tietojen kysely ja suodatus Mongoose-ohjelmistolla

← Takaisin: Node.js-taustakehityksen bootcamp