Jak používat Mongoose v expresních aplikacích

Správa dat v databázi MongoDB může být náročná, zejména při práci se složitými datovými modely. MongoDB je databáze bez schématu, což znamená, že data lze přidávat bez sledování konkrétní struktury. Díky této flexibilitě je MongoDB ideální pro ukládání velkého množství dat, ale také ztěžuje správu dat.

Mongoose poskytuje řešení založené na schématu, které pomáhá zajistit, aby data uložená do MongoDB byla konzistentní a správně naformátovaná. Pomocí Mongoose můžete definovat schéma pro své datové modely, které určuje strukturu dat a pravidla pro formátování těchto dat. Zde prozkoumáte, jak používat Mongoose v aplikaci Express.

Nastavení vývojového prostředí

Než použijete Mongoose, musíte jej nainstalovat jako závislost ve vašem projektu.

Mongoose můžete nainstalovat spuštěním příkazu níže:

npm nainstalovat mongoose

Po instalaci Mongoose do vašeho projektu musíte svou aplikaci připojit k MongoDB pomocí Mongoose.

Mongoose se připojuje k databázi MongoDB pomocí připojit metoda, která jako argument bere MongoDB URI.

Zde je příklad:

// index.js
konst mangusta = vyžadovat("mangusta")
mongoose.connect("mongodb://127.0.0.1:27017/example", () =>
řídicí panel.log("Úspěšně připojeno k databázi")
);

Výše uvedený blok kódu se připojí k místní instanci MongoDB a zaprotokoluje zprávu o úspěchu, když se vaše aplikace úspěšně připojí k MongoDB.

Vytvoření modelu Mongoose

Model Mongoose je třída založená na schématu v Mongoose, která umožňuje interakci s kolekcí MongoDB.

Schéma Mongoose definuje strukturu dokumentů, které můžete uložit do kolekce MongoDB a poskytuje rozhraní pro vytváření, čtení, aktualizaci a mazání dokumentů v něm sbírka.

Když definujete model Mongoose, definujete schéma pro dokumenty v této kolekci, včetně vlastností, jejich typů a případných ověření.

Zde je příklad modelu Mongoose pro a Uživatel sbírka:

konst mangusta = vyžadovat("mangusta");
konst userSchema = mangusta. Schéma({
 název: {
 typ: Tětiva,
 Požadované: [skutečný, "Jméno je povinné"],
 },
 e-mailem: {
 typ: Tětiva,
 Požadované: skutečný,
 },
 věk: {
 typ: Číslo,
 ověřit: {
 validátor: funkce (hodnota) {
vrátit se hodnota > 0;
 },
 zpráva: () =>"Zadejte prosím platný věk",
 },
 },
});
konst Uživatel = mongoose.model("Uživatel", userSchema);
modul.exports = Uživatel;

Výše uvedený blok kódu definuje schéma Mongoose se třemi vlastnostmi: název, e-mailem, a stáří. Každá vlastnost má definovanou sadu pravidel, která musíte dodržovat při mapování hodnoty do jejího zadaného pole. Zde je rozpis pravidel:

• název: The název nemovitost je a tětiva typ označený jako Požadované, což znamená, že musíte na toto pole namapovat řetězec. Pokud necháte pole prázdné nebo zadejte jiné Typ dat JavaScript, Mongoose vyvolá chybu.
• e-mailem: The e-mailem nemovitost je a tětiva typ označený jako Požadované. Nemá žádná další pravidla ověřování, ale v praxi byste měli ověřit, zda je e-mail správný. E-mail můžete ověřit pomocí výrazů regulárních výrazů nebo knihovny třetích stran, jako je class-validator.
• stáří: The stáří nemovitost je a číslo zadejte s vlastním ověřovacím pravidlem, které kontroluje, zda je hodnota mapovaná do pole větší než nula. Pokud hodnota neprojde validací, Mongoose vyvolá chybu se zprávou Zadejte prosím platný věk. Toto pole můžete nechat prázdné, protože není označeno jako Požadované.

Po definování schématu vytvoří blok kódu model Mongoose s názvem Uživatel použitím mongoose.model() metoda. Tato metoda vyžaduje dva argumenty: název modelu a schéma, které se má použít pro dokumenty.

Konečně, Uživatel model se exportuje do jiných částí vaší aplikace.

Interakce s MongoDB pomocí Mongoose

S vaší aplikací připojenou k databázi MongoDB a vaším modelem vytvořeným a přístupným pro ostatní části vaší aplikace můžete s databází pracovat pomocí metod poskytovaných Mongoose.

V tomto tutoriálu vystoupíte Operace CRUD na databázi MongoDB.

Poznámka: Ujistěte se, že importujete svůj model Mongoose do jakéhokoli modulu, kde budete provádět operace CRUD.

Například:

// router.js
konst Uživatel = vyžadovat("./userModel")

Vytvoření dokumentu

Dokument je instancí modelu. Existuje několik způsobů, jak vytvořit a uložit dokument do MongoDB pomocí Mongoose.

Nejprve můžete vytvořit instanci třídy vašeho modelu a poté zavolat Uložit metoda na to.

Například:

//Vytvoření nového uživatele
nechat uživatel = Nový Uživatel({
 název,
 e-mailem,
 stáří,
});
//Uložení uživatele do databáze
uživatel
 .Uložit()
 .pak(() => {
řídicí panel.log("Uživatel byl úspěšně vytvořen");
 })
 .chytit((chyba) => {
//ošetření chyby
 });

Blok kódu výše vytvoří a uloží nový Uživatel dokument do vaší databáze MongoDB.

Data můžete také uložit do databáze pomocí vytvořit metoda. The vytvořit metoda vytvoří instanci vašeho modelu a zavolá Uložit metoda na to. Jednoduše řečeno, kombinuje dvě operace výše uvedené techniky.

Například:

User.create({ jméno, e-mail, věk }, (chyba, data) => {
-li (chybovat) házetNovýChyba("Interní chyba serveru");
řídicí panel.log(`Uživatel byl úspěšně vytvořen: ${data}`);
 });

Blok kódu výše vytvoří nový Uživatel dokument s vlastnostmi předanými jako argument do vytvořit metoda.

Případně můžete data uložit do databáze pomocí vložitMnoho metoda. I když tato metoda je ideální pouze pro ukládání dat v dávkách.

Například:

User.insertMany(
 [
 { jméno, e-mail, věk },
 { jméno_1, email_1, věk_1 },
 ],
 (chyba, výsledek) => {
-li (chyba) {
//ošetření chyby
 } jiný {
//Odeslat výsledky
 }
 }
 );

Blok kódu výše vytvoří dva nové dokumenty v Uživatel kolekce pomocí pole předávaného jako argument do vložitMnoho metoda.

Čtení dokumentu

Ke všem uloženým dokumentům ve vaší databázi MongoDB můžete přistupovat pomocí Mongoose's nalézt metoda.

Například:

User.find({})
 .pak((data) => {
řídicí panel.log (data);
 })
 .chytit((chybovat) => {
//ošetření chyby
 });

Blok kódu výše vrátí všechny dokumenty v Uživatel sbírka.

Všechny dokumenty, které odpovídají konkrétnímu dotazu, můžete také najít předáním dotazu metodě find.

Například:

// najít všechny dokumenty, kde je věk alespoň 18 let
User.find({ stáří: { $gte: 18 } })
 .pak((data) =>řídicí panel.log (data))
 .chytit((chyba) =>řídicí panel.log (chyba));

Blok kódu výše vrátí všechny dokumenty s hodnotou věku vyšší než 18 v Uživatel sbírka.

Případně můžete číst jednotlivé záznamy pomocí findById a předáním ID dokumentu jako argumentu nebo pomocí Najdi jednu a předání filtru jako argumentu.

Například:

//findById
User.findById (id, (chyba, výsledek) => {
-li (výsledek) řídicí panel.log (výsledek);
-li (chyba) řídicí panel.chyba (chyba)
 });
//findOne
User.findOne({ e-mailem: "[email protected]" }).pak((uživatel) => {
-li (!user) {
//ošetření chyby
 }
//odeslat odpověď
 });

Ve výše uvedeném bloku kódu je findById metoda vrátí dokument s odpovídajícím ID. The Najdi jednu metoda vrátí první dokument s e-mailem [email protected].

Aktualizace dokumentu

Dokument na MongoDB můžete aktualizovat pomocí Mongoose pomocí findByIdAndUpdate metoda. Tato metoda bere ID a objekt s aktualizovanými detaily.

Například:

User.findByIdAndUpdate (id, req.body, (chyba, doc) => {
-li (doc) {
//Odeslat odpověď
 }
-li (chyba) {
//ošetření chyby
 }
});

Blok kódu výše aktualizuje dokument, jehož ID se shoduje s poskytnutým ID s poskytnutým objektem aktualizace (req.body).

Smazání dokumentu

Dokument na MongoDB můžete odstranit pomocí Mongoose pomocí findByIdAndDelete metoda. Tato metoda vezme ID jako argument a odstraní dokument s odpovídajícím ID.

Například:

User.findByIdAndDelete (id, (chyba, výsledek) => {
-li (výsledek) {
//Zpracování výsledku
 }
-li (chyba) {
//Oprava chyby
 }
});

Blok kódu výše odstraní dokument s daným ID z vaší databáze MongoDB.

Použití Mongoose ve vašich expresních aplikacích

Tento článek poskytuje přehled toho, jak byste mohli použít Mongoose ve své expresní aplikaci. Pokrývá, jak můžete navázat připojení k MongoDB, strukturovat a ověřovat data uložená v databázi MongoDB a provádět jednoduché operace CRUD.

Použitím Mongoose ve vašich Express aplikacích můžete zjednodušit a zefektivnit interakce mezi vaší aplikací a databází MongoDB.