Sådan bruges Mongoose i Express-applikationer

Håndtering af data i en MongoDB-database kan være udfordrende, især når man har at gøre med komplekse datamodeller. MongoDB er en skemaløs database, hvilket betyder, at data kan tilføjes uden at følge en bestemt struktur. Denne fleksibilitet gør MongoDB ideel til lagring af store mængder data, men gør det også vanskeligere at administrere data.

Mongoose leverer en skemabaseret løsning, der hjælper med at sikre, at data gemt i MongoDB er konsistent og korrekt formateret. Med Mongoose kan du definere et skema for dine datamodeller, som specificerer strukturen af ​​dataene og reglerne for hvordan disse data skal formateres. Her vil du udforske, hvordan du bruger Mongoose i en Express-applikation.

Opsætning af dit udviklingsmiljø

Før du bruger Mongoose, skal du installere det som en afhængighed i dit projekt.

Du kan installere Mongoose ved at køre kommandoen nedenfor:

npm installere mongoose

Når du har installeret Mongoose i dit projekt, skal du forbinde din applikation til MongoDB ved hjælp af Mongoose.

Mongoose opretter forbindelse til en MongoDB-database ved hjælp af Opret forbindelse metode, som tager en MongoDB URI som et argument.

Her er et eksempel:

// index.js
konst mangust = kræve("mangust")
mongoose.connect("mongodb://127.0.0.1:27017/eksempel", () =>
konsol.log("Forbundet til databasen med succes")
);

Kodeblokken ovenfor forbinder til en lokal MongoDB-instans og logger en succesmeddelelse, når din applikation opretter forbindelse til MongoDB.

Oprettelse af en Mongoose Model

En Mongoose-model er en skemabaseret klasse i Mongoose, der giver dig mulighed for at interagere med en MongoDB-samling.

Et Mongoose-skema definerer strukturen af ​​de dokumenter, som du kan gemme i en MongoDB-samling og giver en grænseflade til oprettelse, læsning, opdatering og sletning af dokumenter i det kollektion.

Når du definerer en Mongoose-model, definerer du skemaet for dokumenterne i den samling, inklusive egenskaberne, deres typer og eventuelle valideringer.

Her er et eksempel på en Mongoose-model til en Bruger kollektion:

konst mangust = kræve("mangust");
konst userSchema = mangust. Skema({
 navn: {
 type: Snor,
 påkrævet: [rigtigt, "Navn er påkrævet"],
 },
 e-mail: {
 type: Snor,
 påkrævet: rigtigt,
 },
 alder: {
 type: Nummer,
 valider: {
 validator: fungere (værdi) {
Vend tilbage værdi > 0;
 },
 besked: () =>"Indtast venligst en gyldig alder",
 },
 },
});
konst Bruger = mongoose.model("Bruger", brugerskema);
modul.exports = Bruger;

Kodeblokken ovenfor definerer et Mongoose-skema med tre egenskaber: navn, e-mail, og alder. Hver egenskab har et defineret sæt regler, du skal følge, når du tilknytter en værdi til dets specificerede felt. Her er en oversigt over reglerne:

• navn: Det navn ejendom er en snor type markeret som påkrævet, hvilket betyder, at du skal knytte en streng til dette felt. Hvis du lader feltet stå tomt eller indtaster et andet JavaScript-datatype, Mongoose kaster en fejl.
• e-mail: Det e-mail ejendom er en snor type markeret som påkrævet. Den har ingen andre valideringsregler, men i praksis bør du validere, om e-mailen er korrekt. Du kan validere e-mailen ved hjælp af regex-udtryk eller tredjepartsbiblioteker, såsom klassevalidator.
• alder: Det alder ejendom er en nummer type med en tilpasset valideringsregel, der kontrollerer, om den værdi, der er knyttet til feltet, er større end nul. Hvis værdien ikke består valideringen, smider Mongoose en fejl med beskeden Indtast venligst en gyldig alder. Du kan lade dette felt stå tomt, da det ikke er markeret som påkrævet.

Efter at have defineret skemaet, opretter kodeblokken en Mongoose-model kaldet Bruger ved brug af mongoose.model() metode. Denne metode tager to argumenter: modellens navn og skemaet, der skal bruges til dokumenterne.

Endelig, den Bruger model eksporteres til andre dele af din applikation.

Interagere med MongoDB ved hjælp af Mongoose

Med din applikation forbundet til en MongoDB-database og din model oprettet og tilgængelig for andre dele af din applikation, kan du interagere med din database ved hjælp af metoder leveret af Mongoose.

Til denne tutorial skal du udføre CRUD-operationer på en MongoDB-database.

Bemærk: Sørg for at importere din Mongoose-model til ethvert modul, hvor du skal udføre CRUD-handlingerne.

For eksempel:

// router.js
konst Bruger = kræve("./brugermodel")

Oprettelse af et dokument

Et dokument er en instans af en model. Der er flere måder, du kan oprette og gemme et dokument på MongoDB ved hjælp af Mongoose.

Først kan du oprette en forekomst af din models klasse og derefter kalde Gemme metode på det.

For eksempel:

//Oprettelse af en ny bruger
lade bruger = ny Bruger({
 navn,
 e-mail,
 alder,
});
//Gemmer bruger til database
bruger
 .Gemme()
 .derefter(() => {
konsol.log("Bruger oprettet med succes");
 })
 .fangst((fejl) => {
//handle fejl
 });

Kodeblokken ovenfor opretter og gemmer en ny Bruger dokument til din MongoDB-database.

Du kan også gemme data i din database ved hjælp af skab metode. Det skab metoden instansierer din model og kalder Gemme metode på det. Med ord, den kombinerer de to operationer af den tidligere nævnte teknik.

For eksempel:

User.create({ navn, e-mail, alder }, (fejl, data) => {
hvis (fejl) kastenyFejl("Intern serverfejl");
konsol.log(`Bruger oprettet med succes: ${data}`);
 });

Kodeblokken ovenfor opretter en ny Bruger dokument med egenskaberne videregivet som et argument til skab metode.

Alternativt kan du gemme data i din database ved hjælp af indsæt Mange metode. Selvom denne metode kun er ideel til at gemme data i batches.

For eksempel:

User.insertMany(
 [
 { name, email, age },
 { name_1, email_1, age_1 },
 ],
 (fejl, resultat) => {
hvis (fejl) {
//handle fejl
 } andet {
//Send resultater
 }
 }
 );

Kodeblokken ovenfor opretter to nye dokumenter i Bruger samling ved hjælp af arrayet, der blev overført som et argument til indsæt Mange metode.

Læsning af et dokument

Du kan få adgang til alle de gemte dokumenter i din MongoDB-database ved hjælp af Mongoose's Find metode.

For eksempel:

Bruger.find({})
 .derefter((data) => {
konsol.log (data);
 })
 .fangst((fejl) => {
//handle fejl
 });

Kodeblokken ovenfor returnerer alle dokumenterne i Bruger kollektion.

Du kan også finde alle dokumenter, der matcher en bestemt forespørgsel, ved at sende en forespørgsel til søgemetoden.

For eksempel:

// find alle dokumenter, hvor alderen er mindst 18 år
Bruger.find({ alder: { $gte: 18 } })
 .derefter((data) =>konsol.log (data))
 .fangst((fejl) =>konsol.log (fejl));

Kodeblokken ovenfor returnerer alle dokumenter med en aldersværdi større end 18 i Bruger kollektion.

Alternativt kan du læse enkelte poster ved hjælp af findById metode og sende et dokument-id som et argument eller bruge find en metode og sende et filter som argument.

For eksempel:

//findById
User.findById (id, (fejl, resultat) => {
hvis (resultat) konsol.log (resultat);
hvis (fejl) konsol.error (fejl)
 });
//findOne
User.findOne({ e-mail: "[email protected]" }).derefter((bruger) => {
hvis (!bruger) {
//handle fejl
 }
//send svar
 });

I ovenstående kodeblok er findById metoden returnerer dokumentet med det matchende id. Det find en metode returnerer det første dokument med e-mailen [email protected].

Opdatering af et dokument

Du kan opdatere et dokument på MongoDB med Mongoose ved hjælp af findByIdAndUpdate metode. Denne metode tager et ID og et objekt med de opdaterede detaljer.

For eksempel:

User.findByIdAndUpdate (id, req.body, (err, doc) => {
hvis (doc) {
//Send svar
 }
hvis (fejl) {
//handle fejl
 }
});

Kodeblokken ovenfor opdaterer dokumentet med et ID, der matcher det angivne ID med det angivne opdateringsobjekt (req.body).

Sletning af et dokument

Du kan slette et dokument på MongoDB med Mongoose ved hjælp af findByIdAndDelete metode. Denne metode tager et ID som et argument og sletter dokumentet med det tilsvarende ID.

For eksempel:

User.findByIdAndDelete (id, (fejl, resultat) => {
hvis (resultat) {
//Håndter resultat
 }
hvis (fejl) {
//Håndter fejl
 }
});

Kodeblokken ovenfor sletter et dokument med det angivne ID fra din MongoDB-database.

Brug Mongoose i dine ekspresapplikationer

Denne artikel gav et overblik over, hvordan du kunne bruge Mongoose i din ekspresapplikation. Dækker, hvordan du kan etablere en forbindelse til MongoDB, strukturere og validere data gemt i din MongoDB-database og udføre simple CRUD-operationer.

Ved at bruge Mongoose i dine Express-applikationer kan du forenkle og strømline interaktionerne mellem din applikation og en MongoDB-database.