Jak używać Mongoose w aplikacjach ekspresowych

Zarządzanie danymi w bazie danych MongoDB może być trudne, zwłaszcza w przypadku złożonych modeli danych. MongoDB to baza danych pozbawiona schematów, co oznacza, że ​​dane można dodawać bez przestrzegania określonej struktury. Ta elastyczność sprawia, że ​​MongoDB idealnie nadaje się do przechowywania dużych ilości danych, ale także utrudnia zarządzanie danymi.

Mongoose zapewnia rozwiązanie oparte na schemacie, które pomaga zapewnić, że dane zapisane w MongoDB są spójne i poprawnie sformatowane. Dzięki Mongoose możesz zdefiniować schemat dla swoich modeli danych, który określa strukturę danych i zasady formatowania tych danych. Tutaj dowiesz się, jak używać Mongoose w aplikacji Express.

Konfigurowanie środowiska programistycznego

Przed użyciem Mongoose musisz zainstalować go jako zależność w swoim projekcie.

Możesz zainstalować Mongoose, uruchamiając poniższe polecenie:

npm zainstaluj mangustę

Po zainstalowaniu Mongoose w swoim projekcie musisz połączyć swoją aplikację z MongoDB za pomocą Mongoose.

Mongoose łączy się z bazą danych MongoDB za pomocą łączyć metoda, która jako argument przyjmuje identyfikator URI MongoDB.

Oto przykład:

// index.js
konst mangusta = wymagać("mangusta")
mangusta.połącz("mongodb://127.0.0.1:27017/przyklad", () =>
konsola.dziennik(„Połączono z bazą danych pomyślnie”)
);

Powyższy blok kodu łączy się z lokalną instancją MongoDB i rejestruje komunikat o powodzeniu, gdy aplikacja pomyślnie połączy się z MongoDB.

Tworzenie modelu mangusty

Model Mongoose to oparta na schemacie klasa w Mongoose, która umożliwia interakcję z kolekcją MongoDB.

Schemat Mongoose definiuje strukturę dokumentów, które można przechowywać w kolekcji MongoDB i zapewnia interfejs do tworzenia, czytania, aktualizowania i usuwania dokumentów w tym kolekcja.

Podczas definiowania modelu Mongoose definiujesz schemat dokumentów w tej kolekcji, w tym właściwości, ich typy i wszelkie walidacje.

Oto przykład modelu Mongoose dla Użytkownik kolekcja:

konst mangusta = wymagać("mangusta");
konst userSchema = mangusta. Schemat({
 nazwa: {
 typ: Strunowy,
 wymagany: [PRAWDA, "Imie jest wymagane"],
 },
 e-mail: {
 typ: Strunowy,
 wymagany: PRAWDA,
 },
 wiek: {
 typ: Numer,
 zatwierdź: {
 walidator: funkcjonować (wartość) {
powrót wartość > 0;
 },
 wiadomość: () =>„Proszę wprowadzić poprawny wiek”,
 },
 },
});
konst Użytkownik = mangusta.model("Użytkownik", schemat użytkownika);
moduł.eksport = Użytkownik;

Powyższy blok kodu definiuje schemat Mongoose z trzema właściwościami: nazwa, e-mail, I wiek. Każda właściwość ma zdefiniowany zestaw reguł, których należy przestrzegać podczas mapowania wartości na jej określone pole. Oto zestawienie zasad:

• nazwa: nazwa właściwość jest A strunowy typ oznaczony jako wymagany, co oznacza, że ​​musisz zamapować ciąg znaków na to pole. Jeśli pozostawisz to pole puste lub wpiszesz inne Typ danych JavaScript, Mongoose zgłasza błąd.
• e-mail: e-mail właściwość jest A strunowy typ oznaczony jako wymagany. Nie ma innych zasad sprawdzania poprawności, ale w praktyce należy zweryfikować poprawność wiadomości e-mail. Możesz zweryfikować adres e-mail za pomocą wyrażeń regularnych lub biblioteki stron trzecich, takie jak walidator klas.
• wiek: wiek właściwość jest A numer typu z niestandardową regułą sprawdzania poprawności, która sprawdza, czy wartość odwzorowana na pole jest większa od zera. Jeśli wartość nie przejdzie walidacji, Mongoose zgłosi błąd z komunikatem Podaj prawidłowy wiek. Możesz pozostawić to pole puste, ponieważ nie jest oznaczone jako wymagany.

Po zdefiniowaniu schematu blok kodu tworzy model Mongoose o nazwie Użytkownik za pomocą mangusta.model() metoda. Ta metoda przyjmuje dwa argumenty: nazwę modelu i schemat, który ma być używany w dokumentach.

Wreszcie, Użytkownik model jest eksportowany do innych części aplikacji.

Interakcja z MongoDB za pomocą Mongoose

Gdy Twoja aplikacja jest połączona z bazą danych MongoDB, a Twój model jest utworzony i dostępny dla innych części Twojej aplikacji, możesz wchodzić w interakcje z bazą danych przy użyciu metod dostarczonych przez Mongoose.

W tym samouczku wykonasz Operacje CRUD na bazie danych MongoDB.

Notatka: Pamiętaj, aby zaimportować model Mongoose do dowolnego modułu, w którym będziesz wykonywać operacje CRUD.

Na przykład:

// router.js
konst Użytkownik = wymagać(„./Model użytkownika”)

Tworzenie dokumentu

Dokument jest instancją modelu. Istnieje kilka sposobów tworzenia i zapisywania dokumentów w MongoDB za pomocą Mongoose.

Najpierw możesz utworzyć instancję klasy swojego modelu, a następnie wywołać metodę ratować metoda na to.

Na przykład:

//Tworzenie nowego użytkownika
pozwalać użytkownik = nowy Użytkownik({
 nazwa,
 e-mail,
 wiek,
});
//Zapisywanie użytkownika do bazy danych
użytkownik
 .ratować()
 .Następnie(() => {
konsola.dziennik(„Użytkownik utworzony pomyślnie”);
 })
 .złapać((błąd) => {
//obsługa błędu
 });

Powyższy blok kodu tworzy i zapisuje plik new Użytkownik dokument do bazy danych MongoDB.

Możesz także zapisać dane do swojej bazy danych za pomocą tworzyć metoda. The tworzyć Metoda tworzy instancję twojego modelu i wywołuje metodę ratować metoda na to. Innymi słowy, łączy w sobie dwie operacje wspomnianej wcześniej techniki.

Na przykład:

User.create({ imię i nazwisko, adres e-mail, wiek }, (błąd, dane) => {
Jeśli (błądzić) rzucićnowyBłąd("Wewnętrzny błąd serwera");
konsola.dziennik(`Użytkownik utworzony pomyślnie: ${dane}`);
 });

Powyższy blok kodu tworzy nowy Użytkownik dokument z właściwościami przekazanymi jako argument do metody tworzyć metoda.

Alternatywnie możesz zapisać dane w swojej bazie danych za pomocą wstaw Wiele metoda. Chociaż ta metoda jest idealna tylko do zapisywania danych w partiach.

Na przykład:

User.insertMany(
 [
 { imię i nazwisko, adres e-mail, wiek },
 { nazwa_1, e-mail_1, wiek_1 },
 ],
 (błąd, wynik) => {
Jeśli (błąd) {
//obsługa błędu
 } w przeciwnym razie {
//Wyślij wyniki
 }
 }
 );

Powyższy blok kodu tworzy dwa nowe dokumenty w formacie Użytkownik kolekcji przy użyciu tablicy przekazanej jako argument do metody wstaw Wiele metoda.

Czytanie dokumentu

Możesz uzyskać dostęp do wszystkich zapisanych dokumentów w bazie danych MongoDB za pomocą Mongoose znajdować metoda.

Na przykład:

Znalezienie.użytkownika({})
 .Następnie((dane) => {
konsola.log (dane);
 })
 .złapać((błądzić) => {
//obsługa błędu
 });

Powyższy blok kodu zwróci wszystkie dokumenty w Użytkownik kolekcja.

Możesz także znaleźć wszystkie dokumenty pasujące do określonego zapytania, przekazując zapytanie do metody find.

Na przykład:

// znajdź wszystkie dokumenty, w których wiek wynosi co najmniej 18 lat
user.find({ wiek: { $gte: 18 } })
 .Następnie((dane) =>konsola.log (dane))
 .złapać((błąd) =>konsola.log (błąd));

Powyższy blok kodu zwróci wszystkie dokumenty z wartością wieku większą niż 18 w Użytkownik kolekcja.

Alternatywnie możesz czytać pojedyncze rekordy za pomocą znajdźWgId metody i przekazując identyfikator dokumentu jako argument lub używając metody znajdźJeden metoda i przekazanie filtru jako argumentu.

Na przykład:

//findById
User.findById (id, (błąd, wynik) => {
Jeśli (wynik) konsola.log (wynik);
Jeśli (błąd) konsola.błąd (błąd)
 });
//findOne
User.findOne({ e-mail: „[email protected]” }).Następnie((użytkownik) => {
Jeśli (!użytkownik) {
//obsługa błędu
 }
//wysłać odpowiedź
 });

W powyższym bloku kodu plik znajdźWgId Metoda zwraca dokument o pasującym identyfikatorze. The znajdźJeden Metoda zwraca pierwszy dokument zawierający adres e-mail [email protected].

Aktualizowanie dokumentu

Możesz zaktualizować dokument w MongoDB za pomocą Mongoose, używając findByIdAndUpdate metoda. Ta metoda pobiera identyfikator i obiekt ze zaktualizowanymi szczegółami.

Na przykład:

User.findByIdAndUpdate (id, req.body, (err, doc) => {
Jeśli (dokument) {
//Wysłać odpowiedź
 }
Jeśli (błąd) {
//obsługa błędu
 }
});

Powyższy blok kodu aktualizuje dokument o identyfikatorze pasującym do podanego identyfikatora z podanym obiektem aktualizacji (wymagane ciało).

Usuwanie dokumentu

Możesz usunąć dokument w MongoDB za pomocą Mongoose za pomocą findByIdAndDelete metoda. Ta metoda przyjmuje identyfikator jako argument i usuwa dokument z odpowiednim identyfikatorem.

Na przykład:

User.findByIdAndDelete (id, (błąd, wynik) => {
Jeśli (wynik) {
//Obsługa wyniku
 }
Jeśli (błąd) {
//Obsługa błędu
 }
});

Powyższy blok kodu usuwa dokument o podanym identyfikatorze z bazy danych MongoDB.

Korzystanie z Mongoose w aplikacjach ekspresowych

W tym artykule omówiono, jak można używać Mongoose w aplikacji ekspresowej. Obejmuje sposób nawiązywania połączenia z MongoDB, strukturyzowania i sprawdzania poprawności danych zapisanych w bazie danych MongoDB oraz wykonywania prostych operacji CRUD.

Używając Mongoose w aplikacjach Express, możesz uprościć i usprawnić interakcje między aplikacją a bazą danych MongoDB.