Come utilizzare Mongoose nelle applicazioni Express

La gestione dei dati in un database MongoDB può essere impegnativa, soprattutto quando si ha a che fare con modelli di dati complessi. MongoDB è un database senza schema, il che significa che i dati possono essere aggiunti senza seguire una particolare struttura. Questa flessibilità rende MongoDB ideale per l'archiviazione di grandi quantità di dati, ma rende anche più difficile la gestione dei dati.

Mongoose fornisce una soluzione basata su schema che aiuta a garantire che i dati salvati in MongoDB siano coerenti e formattati correttamente. Con Mongoose, puoi definire uno schema per i tuoi modelli di dati, che specifica la struttura dei dati e le regole per la formattazione dei dati. Qui esplorerai come utilizzare Mongoose in un'applicazione Express.

Configurazione dell'ambiente di sviluppo

Prima di usare Mongoose, devi installarlo come dipendenza nel tuo progetto.

Puoi installare Mongoose eseguendo il comando seguente:

npm installa mangusta

Dopo aver installato Mongoose nel tuo progetto, devi connettere la tua applicazione a MongoDB usando Mongoose.

Mongoose si connette a un database MongoDB utilizzando il Collegare metodo, che accetta un URI MongoDB come argomento.

Ecco un esempio:

// indice.js
cost mangusta = richiedere("mangusta")
mangusta.connect("mongodb://127.0.0.1:27017/esempio", () =>
consolare.tronco d'albero("Connesso al database con successo")
);

Il blocco di codice precedente si connette a un'istanza MongoDB locale e registra un messaggio di successo quando l'applicazione si connette correttamente a MongoDB.

Creazione di un modello di mangusta

Un modello Mongoose è una classe basata su schema in Mongoose che consente di interagire con una raccolta MongoDB.

Uno schema Mongoose definisce la struttura dei documenti che è possibile archiviare in una raccolta MongoDB e fornisce un'interfaccia per la creazione, la lettura, l'aggiornamento e l'eliminazione di documenti in esso collezione.

Quando definisci un modello Mongoose, definisci lo schema per i documenti in quella raccolta, incluse le proprietà, i loro tipi ed eventuali convalide.

Ecco un esempio di un modello Mongoose per a Utente collezione:

cost mangusta = richiedere("mangusta");
cost userSchema = mangusta. Schema({
 nome: {
 tipo: Corda,
 necessario: [VERO, "Il nome è obbligatorio"],
 },
 e-mail: {
 tipo: Corda,
 necessario: VERO,
 },
 età: {
 tipo: Numero,
 convalida: {
 validatore: funzione (valore) {
ritorno valore > 0;
 },
 Messaggio: () =>"Inserisci un'età valida",
 },
 },
});
cost Utente = mangusta.modello("Utente", userSchema);
modulo.exports = Utente;

Il blocco di codice sopra definisce uno schema Mongoose con tre proprietà: nome, e-mail, E età. Ogni proprietà ha un insieme definito di regole che devi seguire durante la mappatura di un valore al campo specificato. Ecco una ripartizione delle regole:

• nome: IL nome la proprietà è un corda tipo contrassegnato come necessario, il che significa che devi mappare una stringa a questo campo. Se lasci il campo vuoto o ne inserisci uno diverso Tipo di dati JavaScript, Mongoose genera un errore.
• e-mail: IL e-mail la proprietà è un corda tipo contrassegnato come necessario. Non ha altre regole di convalida, ma in pratica dovresti convalidare se l'e-mail è corretta. Puoi convalidare l'e-mail utilizzando le espressioni regex o librerie di terze parti, come class-validator.
• età: IL età la proprietà è un numero digitare con una regola di convalida personalizzata che controlla se il valore mappato al campo è maggiore di zero. Se il valore non supera la convalida, Mongoose genera un errore con il messaggio Inserisci un'età valida. Puoi lasciare questo campo vuoto perché non è contrassegnato come necessario.

Dopo aver definito lo schema, il blocco di codice crea un modello Mongoose chiamato Utente utilizzando mangusta.modello() metodo. Questo metodo accetta due argomenti: il nome del modello e lo schema da utilizzare per i documenti.

Infine il Utente il modello viene esportato in altre parti dell'applicazione.

Interagire con MongoDB utilizzando Mongoose

Con la tua applicazione connessa a un database MongoDB e il tuo modello creato e accessibile ad altre parti della tua applicazione, puoi interagire con il tuo database utilizzando i metodi forniti da Mongoose.

Per questo tutorial, ti esibirai Operazioni CRUD su un database MongoDB.

Nota: assicurati di importare il tuo modello Mongoose in qualsiasi modulo in cui eseguirai le operazioni CRUD.

Per esempio:

// router.js
cost Utente = richiedere("./modelloutente")

Creazione di un documento

Un documento è un'istanza di un modello. Esistono diversi modi per creare e salvare un documento su MongoDB utilizzando Mongoose.

Innanzitutto, puoi creare un'istanza della classe del tuo modello e quindi chiamare il salva metodo su di esso.

Per esempio:

//Creazione di un nuovo utente
permettere utente = nuovo Utente({
 nome,
 e-mail,
 età,
});
//Salvataggio dell'utente nel database
utente
 .salva()
 .Poi(() => {
consolare.tronco d'albero("Utente creato con successo");
 })
 .presa((errore) => {
//gestisce l'errore
 });

Il blocco di codice sopra crea e salva un nuovo file Utente documento nel tuo database MongoDB.

Puoi anche salvare i dati nel tuo database usando il file creare metodo. IL creare Il metodo crea un'istanza del modello e chiama il metodo salva metodo su di esso. In parole povere, unisce le due operazioni della tecnica precedentemente citata.

Per esempio:

User.create({ nome, email, età }, (err, dati) => {
Se (errare) gettarenuovoErrore("Errore interno del server");
consolare.tronco d'albero(`Utente creato con successo: ${dati}`);
 });

Il blocco di codice sopra crea un nuovo file Utente documento con le proprietà passate come argomento al file creare metodo.

In alternativa, puoi salvare i dati nel tuo database utilizzando il file inserireMolti metodo. Sebbene questo metodo sia ideale solo per salvare i dati in batch.

Per esempio:

Utente.insertMany(
 [
 {nome, email, età},
 { nome_1, email_1, età_1 },
 ],
 (err, risultato) => {
Se (errare) {
//gestisce l'errore
 } altro {
//Invia i risultati
 }
 }
 );

Il blocco di codice sopra crea due nuovi documenti nel file Utente collection utilizzando l'array passato come argomento a inserireMolti metodo.

Lettura di un documento

Puoi accedere a tutti i documenti salvati nel tuo database MongoDB usando Mongoose Trovare metodo.

Per esempio:

Utente.find({})
 .Poi((dati) => {
consolare.log (dati);
 })
 .presa((errare) => {
//gestisce l'errore
 });

Il blocco di codice sopra restituirà tutti i documenti nel formato Utente collezione.

Puoi anche trovare tutti i documenti che corrispondono a una particolare query passando una query al metodo find.

Per esempio:

// trova tutti i documenti in cui l'età è di almeno 18 anni
Utente.find({ età: { $gte: 18 } })
 .Poi((dati) =>consolare.log (dati))
 .presa((errore) =>consolare.log (errore));

Il blocco di codice sopra restituirà tutti i documenti con un valore di età maggiore di 18 in Utente collezione.

In alternativa, puoi leggere i singoli record utilizzando il file findById metodo e passando un ID documento come argomento o utilizzando il metodo trova uno metodo e passando un filtro come argomento.

Per esempio:

//findById
User.findById (id, (errore, risultato) => {
Se (risultato) consolare.log (risultato);
Se (errore) consolare.errore (errore)
 });
//findOne
Utente.trovaUno({ e-mail: "[email protected]" }).Poi((utente) => {
Se (!utente) {
//gestisce l'errore
 }
//invia risposta
 });

Nel blocco di codice sopra, il findById Il metodo restituisce il documento con l'ID corrispondente. IL trova uno Il metodo restituisce il primo documento contenente l'e-mail [email protected].

Aggiornamento di un documento

Puoi aggiornare un documento su MongoDB con Mongoose usando il file findByIdAndUpdate metodo. Questo metodo accetta un ID e un oggetto con i dettagli aggiornati.

Per esempio:

User.findByIdAndUpdate (id, req.body, (err, doc) => {
Se (doc) {
//Invia risposta
 }
Se (errare) {
//gestisce l'errore
 }
});

Il blocco di codice precedente aggiorna il documento con un ID che corrisponde all'ID fornito con l'oggetto di aggiornamento fornito (req.corpo).

Eliminazione di un documento

Puoi eliminare un documento su MongoDB con Mongoose usando il file findByIdAndDelete metodo. Questo metodo accetta un ID come argomento ed elimina il documento con l'ID corrispondente.

Per esempio:

User.findByIdAndDelete (id, (errore, risultato) => {
Se (risultato) {
// Gestisci il risultato
 }
Se (errore) {
//Gestisci l'errore
 }
});

Il blocco di codice sopra elimina un documento con l'ID specificato dal tuo database MongoDB.

Utilizzo di Mongoose nelle tue applicazioni Express

Questo articolo ha fornito una panoramica di come puoi usare Mongoose nella tua applicazione express. Coprendo come è possibile stabilire una connessione a MongoDB, strutturare e convalidare i dati salvati nel database MongoDB ed eseguire semplici operazioni CRUD.

Utilizzando Mongoose nelle tue applicazioni Express, puoi semplificare e ottimizzare le interazioni tra la tua applicazione e un database MongoDB.