Integrer Node.js-applikasjonen din med en MongoDB-database ved å bruke Mongoose.
Å administrere data i en MongoDB-database kan være utfordrende, spesielt når du arbeider med komplekse datamodeller. MongoDB er en skjemaløs database, noe som betyr at data kan legges til uten å følge en bestemt struktur. Denne fleksibiliteten gjør MongoDB ideell for lagring av store datamengder, men gjør det også vanskeligere å administrere data.
Mongoose tilbyr en skjemabasert løsning som bidrar til å sikre at data som er lagret i MongoDB er konsistente og riktig formatert. Med Mongoose kan du definere et skjema for datamodellene dine, som spesifiserer strukturen til dataene og reglene for hvordan dataene skal formateres. Her vil du utforske hvordan du bruker Mongoose i en Express-applikasjon.
Sette opp utviklingsmiljøet ditt
Før du bruker Mongoose, må du installere den som en avhengighet i prosjektet ditt.
Du kan installere Mongoose ved å kjøre kommandoen nedenfor:
npm installer mongoose
Etter at du har installert Mongoose i prosjektet ditt, må du koble applikasjonen til MongoDB ved hjelp av Mongoose.
Mongoose kobler til en MongoDB-database ved hjelp av koble metode, som tar en MongoDB URI som et argument.
Her er et eksempel:
// index.js
konst mangust = krever("mangus")mongoose.connect("mongodb://127.0.0.1:27017/eksempel", () =>
konsoll.Logg("Koblet til databasen vellykket")
);
Kodeblokken ovenfor kobles til en lokal MongoDB-forekomst og logger en suksessmelding når applikasjonen din kobles til MongoDB.
Opprette en Mongoose-modell
En Mongoose-modell er en skjemabasert klasse i Mongoose som lar deg samhandle med en MongoDB-samling.
Et Mongoose-skjema definerer strukturen til dokumentene du kan lagre i en MongoDB-samling og gir et grensesnitt for å opprette, lese, oppdatere og slette dokumenter i det samling.
Når du definerer en Mongoose-modell, definerer du skjemaet for dokumentene i den samlingen, inkludert egenskapene, typene deres og eventuelle valideringer.
Her er et eksempel på en Mongoose-modell for en Bruker samling:
konst mangust = krever("mangus");konst userSchema = mongoose. Skjema({
Navn: {
type: String,
nødvendig: [ekte, "Navn kreves"],
},
e-post: {
type: String,
nødvendig: ekte,
},
alder: {
type: Antall,
validere: {
validator: funksjon (verdi) {
komme tilbake verdi > 0;
},
beskjed: () =>"Vennligst angi en gyldig alder",
},
},
});konst Bruker = mongoose.model("Bruker", brukerskjema);
modul.exports = Bruker;
Kodeblokken ovenfor definerer et Mongoose-skjema med tre egenskaper: Navn, e-post, og alder. Hver egenskap har et definert sett med regler du må følge når du tilordner en verdi til det spesifiserte feltet. Her er en oversikt over reglene:
- Navn: Den Navn eiendom er en streng type merket som nødvendig, noe som betyr at du må tilordne en streng til dette feltet. Hvis du lar feltet stå tomt eller skriver inn et annet JavaScript-datatype, Mongoose kaster en feil.
- e-post: Den e-post eiendom er en streng type merket som nødvendig. Den har ingen andre valideringsregler, men i praksis bør du validere om e-posten er korrekt. Du kan bekrefte e-posten ved hjelp av regex-uttrykk eller tredjepartsbiblioteker, for eksempel klassevalidator.
- alder: Den alder eiendom er en Antall type med en egendefinert valideringsregel som sjekker om verdien som er tilordnet feltet er større enn null. Hvis verdien ikke består valideringen, gir Mongoose en feilmelding med meldingen Vennligst skriv inn en gyldig alder. Du kan la dette feltet stå tomt da det ikke er merket som nødvendig.
Etter å ha definert skjemaet, lager kodeblokken en Mongoose-modell kalt Bruker ved hjelp av mongoose.model() metode. Denne metoden tar to argumenter: modellens navn og skjemaet som skal brukes for dokumentene.
Til slutt, den Bruker modellen eksporteres til andre deler av programmet.
Samhandle med MongoDB ved å bruke Mongoose
Med applikasjonen din koblet til en MongoDB-database og modellen din opprettet og tilgjengelig for andre deler av applikasjonen din, kan du samhandle med databasen din ved å bruke metoder levert av Mongoose.
For denne opplæringen skal du utføre CRUD-operasjoner på en MongoDB-database.
Merk: Sørg for å importere Mongoose-modellen din til en hvilken som helst modul der du skal utføre CRUD-operasjonene.
For eksempel:
// router.js
konst Bruker = krever("./brukermodell")
Opprette et dokument
Et dokument er en forekomst av en modell. Det er flere måter du kan opprette og lagre et dokument til MongoDB ved å bruke Mongoose.
Først kan du opprette en forekomst av modellens klasse og deretter ringe lagre metode på det.
For eksempel:
//Opprette en ny bruker
la bruker = ny Bruker({
Navn,
e-post,
alder,
});
//Lagre bruker til database
bruker
.lagre()
.deretter(() => {
konsoll.Logg("Bruker opprettet vellykket");
})
.å fange((feil) => {
//håndtaksfeil
});
Kodeblokken ovenfor oppretter og lagrer en ny Bruker dokument til MongoDB-databasen din.
Du kan også lagre data til databasen din ved å bruke skape metode. De skape metoden instansierer modellen din og kaller lagre metode på det. I orden kombinerer den de to operasjonene til den tidligere nevnte teknikken.
For eksempel:
User.create({ navn, e-post, alder }, (feil, data) => {
hvis (feil) kastenyFeil("Intern server feil");
konsoll.Logg(`Bruker opprettet vellykket: ${data}`);
});
Kodeblokken ovenfor oppretter en ny Bruker dokument med egenskapene sendt som argument til skape metode.
Alternativt kan du lagre data i databasen din ved å bruke sett innMange metode. Selv om denne metoden bare er ideell for å lagre data i grupper.
For eksempel:
User.insertMany(
[
{ name, email, age },
{ name_1, email_1, age_1 },
],
(feil, resultat) => {
hvis (feil) {
//håndtaksfeil
} ellers {
//Send resultater
}
}
);
Kodeblokken ovenfor oppretter to nye dokumenter i Bruker samling som bruker matrisen som ble sendt som et argument til sett innMange metode.
Lese et dokument
Du kan få tilgang til alle de lagrede dokumentene i MongoDB-databasen din ved å bruke Mongoose's finne metode.
For eksempel:
Bruker.finn({})
.deretter((data) => {
konsoll.log (data);
})
.å fange((feil) => {
//håndtaksfeil
});
Kodeblokken ovenfor vil returnere alle dokumentene i Bruker samling.
Du kan også finne alle dokumenter som samsvarer med et bestemt søk ved å sende en forespørsel til finnmetoden.
For eksempel:
// finn alle dokumenter der alderen er minst 18 år
Bruker.finn({ alder: { $gte: 18 } })
.deretter((data) =>konsoll.log (data))
.å fange((feil) =>konsoll.log (feil));
Kodeblokken ovenfor vil returnere alle dokumentene med en aldersverdi større enn 18 i Bruker samling.
Alternativt kan du lese enkeltposter ved å bruke findById metode og sende en dokument-ID som argument eller bruke Finn én metode og sende et filter som et argument.
For eksempel:
//findById
User.findById (id, (feil, resultat) => {
hvis (resultat) konsoll.log (resultat);
hvis (feil) konsoll.error (feil)
});
//findOne
User.findOne({ e-post: "[email protected]" }).deretter((bruker) => {
hvis (!bruker) {
//håndtaksfeil
}
//send svar
});
I kodeblokken ovenfor er findById metoden returnerer dokumentet med samsvarende ID. De Finn én metoden returnerer det første dokumentet med e-posten [email protected].
Oppdatering av et dokument
Du kan oppdatere et dokument på MongoDB med Mongoose ved å bruke findByIdAndUpdate metode. Denne metoden tar en ID og et objekt med de oppdaterte detaljene.
For eksempel:
User.findByIdAndUpdate (id, req.body, (err, doc) => {
hvis (dok) {
//Send svar
}
hvis (feil) {
//håndtaksfeil
}
});
Kodeblokken ovenfor oppdaterer dokumentet som har en ID som samsvarer med den angitte IDen med det oppgitte oppdateringsobjektet (req.body).
Sletting av et dokument
Du kan slette et dokument på MongoDB med Mongoose ved å bruke findByIdAndDelete metode. Denne metoden tar en ID som et argument og sletter dokumentet med den tilsvarende IDen.
For eksempel:
User.findByIdAndDelete (id, (feil, resultat) => {
hvis (resultat) {
//Håndter resultat
}
hvis (feil) {
//Håndter feil
}
});
Kodeblokken ovenfor sletter et dokument med den gitte IDen fra MongoDB-databasen din.
Bruke Mongoose i ekspressapplikasjonene dine
Denne artikkelen ga en oversikt over hvordan du kan bruke Mongoose i ekspressapplikasjonen din. Dekker hvordan du kan etablere en tilkobling til MongoDB, strukturere og validere data som er lagret i MongoDB-databasen, og utføre enkle CRUD-operasjoner.
Ved å bruke Mongoose i Express-applikasjonene dine kan du forenkle og strømlinjeforme interaksjonene mellom applikasjonen og en MongoDB-database.