Hur man använder Mongoose i Express-applikationer

Att hantera data i en MongoDB-databas kan vara utmanande, särskilt när man hanterar komplexa datamodeller. MongoDB är en schemalös databas, vilket innebär att data kan läggas till utan att följa en viss struktur. Denna flexibilitet gör MongoDB idealisk för att lagra stora mängder data men gör det också svårare att hantera data.

Mongoose tillhandahåller en schemabaserad lösning som hjälper till att säkerställa att data som sparats i MongoDB är konsekvent och korrekt formaterad. Med Mongoose kan du definiera ett schema för dina datamodeller, som specificerar strukturen på datan och reglerna för hur dessa data ska formateras. Här kommer du att utforska hur du använder Mongoose i en Express-applikation.

Konfigurera din utvecklingsmiljö

Innan du använder Mongoose måste du installera det som ett beroende i ditt projekt.

Du kan installera Mongoose genom att köra kommandot nedan:

npm installera mongoose

När du har installerat Mongoose i ditt projekt måste du ansluta din applikation till MongoDB med Mongoose.

Mongoose ansluter till en MongoDB-databas med hjälp av ansluta metod, som tar en MongoDB URI som ett argument.

Här är ett exempel:

// index.js
konst mangust = behöva("mungo")
mongoose.connect("mongodb://127.0.0.1:27017/exempel", () =>
trösta.logga("Ansluten till databasen framgångsrikt")
);

Kodblocket ovan ansluter till en lokal MongoDB-instans och loggar ett framgångsmeddelande när din applikation lyckas ansluta till MongoDB.

Skapa en Mongoose-modell

En Mongoose-modell är en schemabaserad klass i Mongoose som låter dig interagera med en MongoDB-samling.

Ett Mongoose-schema definierar strukturen för de dokument som du kan lagra i en MongoDB-samling och tillhandahåller ett gränssnitt för att skapa, läsa, uppdatera och ta bort dokument i den samling.

När du definierar en Mongoose-modell definierar du schemat för dokumenten i den samlingen, inklusive egenskaperna, deras typer och eventuella valideringar.

Här är ett exempel på en Mongoose-modell för en Användare samling:

konst mangust = behöva("mungo");
konst userSchema = mongoose. Schema({
 namn: {
 typ: Sträng,
 krävs: [Sann, "Namn krävs"],
 },
 e-post: {
 typ: Sträng,
 nödvändig: Sann,
 },
 ålder: {
 typ: siffra,
 validera: {
 validator: fungera (värde) {
lämna tillbaka värde > 0;
 },
 meddelande: () =>"Vänligen ange en giltig ålder",
 },
 },
});
konst Användare = mongoose.model("Användare", userSchema);
modul.exports = Användare;

Kodblocket ovan definierar ett Mongoose-schema med tre egenskaper: namn, e-post, och ålder. Varje egenskap har en definierad uppsättning regler som du måste följa när du mappar ett värde till dess angivna fält. Här är en uppdelning av reglerna:

• namn: Den namn egendom är en sträng typ markerad som nödvändig, vilket innebär att du måste mappa en sträng till detta fält. Om du lämnar fältet tomt eller anger ett annat JavaScript-datatyp, Mongoose ger ett fel.
• e-post: Den e-post egendom är en sträng typ markerad som nödvändig. Den har inga andra valideringsregler, men i praktiken bör du validera om e-postmeddelandet är korrekt. Du kan validera e-postmeddelandet använda regex-uttryck eller tredjepartsbibliotek, till exempel class-validator.
• ålder: Den ålder egendom är en siffra typ med en anpassad valideringsregel som kontrollerar om värdet som mappas till fältet är större än noll. Om värdet inte klarar valideringen, skickar Mongoose ett felmeddelande med meddelandet Vänligen ange en giltig ålder. Du kan lämna detta fält tomt eftersom det inte är markerat som nödvändig.

Efter att ha definierat schemat skapar kodblocket en Mongoose-modell som kallas Användare använder sig av mongoose.model() metod. Denna metod tar två argument: modellens namn och schemat som ska användas för dokumenten.

Slutligen, den Användare modellen exporteras till andra delar av din applikation.

Interagera med MongoDB med Mongoose

Med din applikation ansluten till en MongoDB-databas och din modell skapad och tillgänglig för andra delar av din applikation, kan du interagera med din databas med metoder som tillhandahålls av Mongoose.

För denna handledning kommer du att utföra CRUD-operationer på en MongoDB-databas.

Notera: Se till att importera din Mongoose-modell till valfri modul där du ska utföra CRUD-operationerna.

Till exempel:

// router.js
konst Användare = behöva("./userModel")

Skapa ett dokument

Ett dokument är en instans av en modell. Det finns flera sätt att skapa och spara ett dokument till MongoDB med Mongoose.

Först kan du skapa en instans av din modells klass och sedan anropa spara metod på det.

Till exempel:

//Skapa en ny användare
låta användare = ny Användare({
 namn,
 e-post,
 ålder,
});
//Spara användare till databas
användare
 .spara()
 .sedan(() => {
trösta.logga("Användaren skapades framgångsrikt");
 })
 .fånga((fel) => {
//hantera fel
 });

Kodblocket ovan skapar och sparar en ny Användare dokument till din MongoDB-databas.

Du kan också spara data till din databas med hjälp av skapa metod. De skapa metoden instansierar din modell och anropar spara metod på det. Med ord, den kombinerar de två operationerna av den tidigare nämnda tekniken.

Till exempel:

User.create({ name, email, age }, (err, data) => {
om (fela) kastanyFel("Internt serverfel");
trösta.logga(`Användaren skapades framgångsrikt: ${data}`);
 });

Kodblocket ovan skapar en ny Användare dokument med egenskaperna som skickas som argument till skapa metod.

Alternativt kan du spara data till din databas med hjälp av infoga Många metod. Även om denna metod endast är idealisk för att spara data i omgångar.

Till exempel:

User.insertMany(
 [
 { namn, e-postadress, ålder },
 { name_1, email_1, age_1 },
 ],
 (fel, resultat) => {
om (fel) {
//hantera fel
 } annan {
//Skicka resultat
 }
 }
 );

Kodblocket ovan skapar två nya dokument i Användare samling som använder matrisen som ett argument till infoga Många metod.

Läsa ett dokument

Du kan komma åt alla sparade dokument i din MongoDB-databas med Mongoose's hitta metod.

Till exempel:

User.find({})
 .sedan((data) => {
trösta.log (data);
 })
 .fånga((fela) => {
//hantera fel
 });

Kodblocket ovan kommer att returnera alla dokument i Användare samling.

Du kan också hitta alla dokument som matchar en viss fråga genom att skicka en fråga till sökmetoden.

Till exempel:

// hitta alla dokument där åldern är minst 18 år
User.find({ ålder: { $gte: 18 } })
 .sedan((data) =>trösta.log (data))
 .fånga((fel) =>trösta.log (fel));

Kodblocket ovan returnerar alla dokument med ett åldersvärde högre än 18 i Användare samling.

Alternativt kan du läsa enstaka poster med hjälp av findById metod och skicka ett dokument-ID som ett argument eller använda hitta en metod och skicka ett filter som ett argument.

Till exempel:

//findById
User.findById (id, (fel, resultat) => {
om (resultat) trösta.log (resultat);
om (fel) trösta.error (fel)
 });
//findOne
User.findOne({ e-post: "[email protected]" }).sedan((användare) => {
om (!användare) {
//hantera fel
 }
//skicka svar
 });

I kodblocket ovan visas findById metod returnerar dokumentet med matchande ID. De hitta en metod returnerar det första dokumentet med e-postmeddelandet [email protected].

Uppdatera ett dokument

Du kan uppdatera ett dokument på MongoDB med Mongoose med hjälp av findByIdAndUpdate metod. Denna metod tar ett ID och ett objekt med uppdaterade detaljer.

Till exempel:

User.findByIdAndUpdate (id, req.body, (err, doc) => {
om (doc) {
//Skicka svar
 }
om (fel) {
//hantera fel
 }
});

Kodblocket ovan uppdaterar dokumentet som har ett ID som matchar det angivna ID: t med det angivna uppdateringsobjektet (req.body).

Ta bort ett dokument

Du kan ta bort ett dokument på MongoDB med Mongoose med hjälp av findByIdAndDelete metod. Denna metod tar ett ID som ett argument och tar bort dokumentet med motsvarande ID.

Till exempel:

User.findByIdAndDelete (id, (fel, resultat) => {
om (resultat) {
//Hantera resultat
 }
om (fel) {
//Hanteringsfel
 }
});

Kodblocket ovan tar bort ett dokument med det angivna ID: t från din MongoDB-databas.

Använda Mongoose i dina Express-applikationer

Den här artikeln gav en översikt över hur du kan använda Mongoose i din expressapplikation. Täcker hur du kan upprätta en anslutning till MongoDB, strukturera och validera data som sparats i din MongoDB-databas och utföra enkla CRUD-operationer.

Genom att använda Mongoose i dina Express-applikationer kan du förenkla och effektivisera interaktionerna mellan din applikation och en MongoDB-databas.