A Mongoose használata Express alkalmazásokban

Az adatok kezelése egy MongoDB adatbázisban kihívást jelenthet, különösen összetett adatmodellek esetén. A MongoDB egy séma nélküli adatbázis, ami azt jelenti, hogy az adatok adott struktúra követése nélkül is hozzáadhatók. Ez a rugalmasság ideálissá teszi a MongoDB-t nagy mennyiségű adat tárolására, de az adatok kezelését is megnehezíti.

A Mongoose egy séma alapú megoldást kínál, amely segít biztosítani, hogy a MongoDB-be mentett adatok konzisztensek és helyesen formázva legyenek. A Mongoose segítségével meghatározhat egy sémát az adatmodellekhez, amely meghatározza az adatok szerkezetét és az adatok formázására vonatkozó szabályokat. Itt megtudhatja, hogyan használhatja a Mongoose-t egy Express alkalmazásban.

Fejlesztői környezet beállítása

A Mongoose használata előtt telepítenie kell a projekt függőségeként.

A Mongoose-t az alábbi parancs futtatásával telepítheti:

npm install mongoose

Miután telepítette a Mongoose-t a projektben, az alkalmazást a Mongoose segítségével kell csatlakoztatnia a MongoDB-hez.

A Mongoose a MongoDB adatbázishoz csatlakozik a csatlakozni metódust, amely egy MongoDB URI-t vesz argumentumként.

Íme egy példa:

// index.js
const mangúz = igényelnek("indiai menyét")
mongoose.connect("mongodb://127.0.0.1:27017/example", () =>
konzol.log("Sikeresen csatlakozott az adatbázishoz")
);

A fenti kódblokk egy helyi MongoDB-példányhoz csatlakozik, és sikeres üzenetet naplóz, amikor az alkalmazás sikeresen csatlakozik a MongoDB-hez.

Mongoose modell készítése

A Mongoose-modell egy sémaalapú osztály a Mongoose-ban, amely lehetővé teszi a MongoDB-gyűjteményekkel való interakciót.

A Mongoose-séma határozza meg a MongoDB-gyűjteményben tárolható dokumentumok szerkezetét és felületet biztosít a dokumentumok létrehozásához, olvasásához, frissítéséhez és törléséhez Gyűjtemény.

Amikor Mongoose-modellt definiál, meg kell határoznia a gyűjteményben lévő dokumentumok sémáját, beleértve a tulajdonságokat, típusaikat és az esetleges érvényesítéseket.

Íme egy példa a Mongoose modellre a Felhasználó Gyűjtemény:

const mangúz = igényelnek("indiai menyét");
const userSchema = mangúz. Séma({
 név: {
 típus: Húr,
 szükséges: [igaz, "A név kötelező"],
 },
 email: {
 típus: Húr,
 kívánt: igaz,
 },
 életkor: {
 típus: Szám,
 érvényesít: {
 érvényesítő: funkció (érték) {
Visszatérés érték > 0;
 },
 üzenet: () =>"Kérjük, adjon meg egy érvényes életkort",
 },
 },
});
const User = mongoose.model("Felhasználó", userSchema);
modult.exports = Felhasználó;

A fenti kódblokk egy Mongoose sémát határoz meg három tulajdonsággal: név, email, és kor. Minden tulajdonságnak van egy meghatározott szabálykészlete, amelyet követnie kell, amikor egy értéket a megadott mezőre rendel. Íme a szabályok részletezése:

• név: A név ingatlan a húr típusként jelölve kívánt, vagyis ehhez a mezőhöz egy karakterláncot kell leképeznie. Ha üresen hagyja a mezőt, vagy másikat ír be JavaScript adattípus, Mongoose hibát dob.
• email: A email ingatlan a húr típusként jelölve kívánt. Nincs más érvényesítési szabálya, de a gyakorlatban ellenőriznie kell, hogy az e-mail helyes-e. Érvényesítheti az e-mailt reguláris kifejezések használatával vagy harmadik féltől származó könyvtárak, például osztályellenőrző.
• kor: A kor ingatlan a szám írja be egy egyéni érvényesítési szabállyal, amely ellenőrzi, hogy a mezőre leképezett érték nagyobb-e nullánál. Ha az érték nem megy át az érvényesítésen, a Mongoose hibát jelez az üzenettel Adjon meg egy érvényes életkort. Ezt a mezőt üresen hagyhatja, mivel nincs megjelölve kívánt.

A séma meghatározása után a kódblokk létrehoz egy Mongoose modellt, melynek neve Felhasználó segítségével mongoose.model() módszer. Ez a módszer két argumentumot használ: a modell nevét és a dokumentumokhoz használandó sémát.

Végül a Felhasználó modell exportálva van az alkalmazás más részeibe.

Interakció a MongoDB-vel a Mongoose használatával

Ha az alkalmazás csatlakozik egy MongoDB adatbázishoz, és a modell létrejött és elérhető az alkalmazás más részei számára, akkor a Mongoose által biztosított módszerekkel interakcióba léphet az adatbázissal.

Ebben az oktatóanyagban Ön fog előadni CRUD műveletek MongoDB adatbázison.

jegyzet: Ügyeljen arra, hogy a Mongoose modelljét importálja minden olyan modulba, ahol a CRUD műveleteket végrehajtja.

Például:

// router.js
const Felhasználó = igényelnek("./userModel")

Dokumentum létrehozása

A dokumentum egy modell példánya. A Mongoose használatával többféleképpen hozhat létre és menthet dokumentumot a MongoDB-be.

Először létrehozhat egy példányt a modell osztályából, majd meghívhatja a megment módszer rajta.

Például:

//Új felhasználó létrehozása
hagyja felhasználó = új Felhasználó({
 név,
 email,
 kor,
});
//Felhasználó mentése adatbázisba
felhasználó
 .megment()
 .akkor(() => {
konzol.log("A felhasználó sikeresen létrehozva");
 })
 .fogás((hiba) => {
//kezelő hiba
 });

A fenti kódblokk újat hoz létre és ment el Felhasználó dokumentumot a MongoDB adatbázisába.

Az adatokat az adatbázisba is mentheti a teremt módszer. A teremt metódus példányosítja a modellt, és meghívja a megment módszer rajta. Sorrendben a korábban említett technika két műveletét egyesíti.

Például:

User.create({ név, e-mail, életkor }, (hiba, adatok) => {
ha (téved) dobásújHiba("Belső Szerverhiba");
konzol.log(`Felhasználó sikeresen létrehozva: ${data}`);
 });

A fenti kódblokk újat hoz létre Felhasználó dokumentum a tulajdonságokkal, amelyeket argumentumként adtak át a teremt módszer.

Alternatív megoldásként az adatokat az adatbázisba mentheti a insertMany módszer. Bár ez a módszer csak az adatok kötegelt mentésére ideális.

Például:

User.insertMany(
 [
 { név, e-mail cím, életkor },
 { name_1, email_1, age_1 },
 ],
 (hiba, eredmény) => {
ha (hiba) {
//kezelő hiba
 } más {
//Eredmények küldése
 }
 }
 );

A fenti kódblokk két új dokumentumot hoz létre a Felhasználó gyűjtemény az argumentumként átadott tömb használatával insertMany módszer.

Dokumentum olvasása

A Mongoose adatbázisában lévő összes mentett dokumentumot elérheti a Mongoose segítségével megtalálja módszer.

Például:

User.find({})
 .akkor((adat) => {
konzol.log (adatok);
 })
 .fogás((téved) => {
//kezelő hiba
 });

A fenti kódblokk visszaadja az összes dokumentumot a Felhasználó Gyűjtemény.

Megtalálhatja az összes olyan dokumentumot is, amely megfelel egy adott lekérdezésnek, ha átad egy lekérdezést a keresési metódusnak.

Például:

// megtalálja az összes olyan dokumentumot, amely legalább 18 éves
User.find({ kor: { $gte: 18 } })
 .akkor((adat) =>konzol.log (adatok))
 .fogás((hiba) =>konzol.log (hiba));

A fenti kódblokk visszaadja az összes olyan dokumentumot, amelynek életkora meghaladja a 18-at Felhasználó Gyűjtemény.

Alternatív megoldásként egyetlen rekordot is olvashat a findById metódust és a dokumentumazonosítót argumentumként adjuk át, vagy a találj egyet módszert, és argumentumként egy szűrőt adunk át.

Például:

//findById
User.findById (id, (hiba, eredmény) => {
ha (eredmény) konzol.log (eredmény);
ha (hiba) konzol.error (hiba)
 });
//findOne
User.findOne({ email: "[email protected]" }).akkor((felhasználó) => {
ha (!felhasználó) {
//kezelő hiba
 }
//válasz küldése
 });

A fenti kódblokkban a findById metódus visszaadja a dokumentumot a megfelelő azonosítóval. A találj egyet metódus visszaadja az első dokumentumot, amely az e-mailt tartalmazza [email protected].

Dokumentum frissítése

A MongoDB-n lévő dokumentumokat a Mongoose segítségével frissítheti a findByIdAndUpdate módszer. Ez a módszer egy azonosítót és egy objektumot vesz igénybe a frissített részletekkel.

Például:

User.findByIdAndUpdate (id, req.body, (err, doc) => {
ha (doc) {
//Válasz küldése
 }
ha (hiba) {
//kezelő hiba
 }
});

A fenti kódblokk frissíti azt a dokumentumot, amelynek azonosítója megegyezik a megadott azonosítóval a megadott frissítési objektummal (req.body).

Dokumentum törlése

Törölhet egy dokumentumot a MongoDB-n a Mongoose segítségével a findByIdAndDelete módszer. Ez a metódus egy azonosítót vesz fel argumentumként, és törli a megfelelő azonosítóval rendelkező dokumentumot.

Például:

User.findByIdAndDelete (id, (hiba, eredmény) => {
ha (eredmény) {
//Eredmény kezelése
 }
ha (hiba) {
//Kezelési hiba
 }
});

A fenti kódblokk törli a megadott azonosítójú dokumentumot a MongoDB adatbázisából.

A Mongoose használata az expressz alkalmazásokban

Ez a cikk áttekintést adott arról, hogyan használhatja a Mongoose-t az expressz alkalmazásban. Leírja, hogyan hozhat létre kapcsolatot a MongoDB-vel, hogyan strukturálhatja és ellenőrizheti a MongoDB-adatbázisba mentett adatokat, és hogyan hajthat végre egyszerű CRUD-műveleteket.

A Mongoose használatával az Express-alkalmazásaiban leegyszerűsítheti és racionalizálhatja az alkalmazás és a MongoDB adatbázis közötti interakciókat.