So verwenden Sie Mongoose in Express-Anwendungen

Die Verwaltung von Daten in einer MongoDB-Datenbank kann eine Herausforderung darstellen, insbesondere wenn es um komplexe Datenmodelle geht. MongoDB ist eine schemalose Datenbank, d. h. Daten können hinzugefügt werden, ohne einer bestimmten Struktur zu folgen. Diese Flexibilität macht MongoDB ideal für die Speicherung großer Datenmengen, erschwert aber auch die Datenverwaltung.

Mongoose bietet eine schemabasierte Lösung, mit der sichergestellt werden kann, dass in MongoDB gespeicherte Daten konsistent und korrekt formatiert sind. Mit Mongoose können Sie ein Schema für Ihre Datenmodelle definieren, das die Struktur der Daten und die Regeln für die Formatierung dieser Daten angibt. Hier erfahren Sie, wie Sie Mongoose in einer Express-Anwendung verwenden.

Einrichten Ihrer Entwicklungsumgebung

Bevor Sie Mongoose verwenden, müssen Sie es als Abhängigkeit in Ihrem Projekt installieren.

Sie können Mongoose installieren, indem Sie den folgenden Befehl ausführen:

npm installiert Mungo

Nachdem Sie Mongoose in Ihrem Projekt installiert haben, müssen Sie Ihre Anwendung über Mongoose mit MongoDB verbinden.

Mongoose verbindet sich mit einer MongoDB-Datenbank über die verbinden -Methode, die einen MongoDB-URI als Argument verwendet.

Hier ist ein Beispiel:

// index.js
konst Mungo = erfordern("Mungo")
Mungo.connect ("mongodb://127.0.0.1:27017/Beispiel", () =>
Konsole.Protokoll("Verbindung zur Datenbank erfolgreich hergestellt")
);

Der obige Codeblock stellt eine Verbindung zu einer lokalen MongoDB-Instanz her und protokolliert eine Erfolgsmeldung, wenn Ihre Anwendung erfolgreich eine Verbindung zu MongoDB herstellt.

Erstellen eines Mongoose-Modells

Ein Mongoose-Modell ist eine schemabasierte Klasse in Mongoose, mit der Sie mit einer MongoDB-Sammlung interagieren können.

Ein Mongoose-Schema definiert die Struktur der Dokumente, die Sie in einer MongoDB-Sammlung speichern können und bietet eine Schnittstelle zum Erstellen, Lesen, Aktualisieren und Löschen von Dokumenten darin Sammlung.

Wenn Sie ein Mongoose-Modell definieren, definieren Sie das Schema für die Dokumente in dieser Sammlung, einschließlich der Eigenschaften, ihrer Typen und etwaiger Validierungen.

Hier ist ein Beispiel für ein Mongoose-Modell für a Benutzer Sammlung:

konst Mungo = erfordern("Mungo");
konst userSchema = Mungo. Schema({
 Name: {
 Typ: Schnur,
 erforderlich: [WAHR, "Name ist erforderlich"],
 },
 Email: {
 Typ: Schnur,
 erforderlich: WAHR,
 },
 Alter: {
 Typ: Nummer,
 validieren: {
 Prüfer: Funktion (Wert) {
zurückkehren Wert > 0;
 },
 Nachricht: () =>"Bitte geben Sie ein gültiges Alter ein",
 },
 },
});
konst Benutzer = mongoose.model ("Benutzer", Benutzerschema);
Modul.exports = Benutzer;

Der obige Codeblock definiert ein Mongoose-Schema mit drei Eigenschaften: Name, Email, Und Alter. Jede Eigenschaft hat einen definierten Satz von Regeln, die Sie befolgen müssen, wenn Sie einen Wert seinem angegebenen Feld zuordnen. Hier ist eine Aufschlüsselung der Regeln:

• Name: Der Name Eigentum ist ein Schnur Typ markiert als erforderlich, was bedeutet, dass Sie diesem Feld eine Zeichenfolge zuordnen müssen. Wenn Sie das Feld leer lassen oder eine andere eingeben JavaScript-Datentyp, Mongoose gibt einen Fehler aus.
• Email: Der Email Eigentum ist ein Schnur Typ markiert als erforderlich. Es hat keine anderen Validierungsregeln, aber in der Praxis sollten Sie überprüfen, ob die E-Mail korrekt ist. Sie können die E-Mail validieren Verwendung von Regex-Ausdrücken oder Bibliotheken von Drittanbietern wie Class-Validator.
• Alter: Der Alter Eigentum ist ein Nummer Typ mit einer benutzerdefinierten Validierungsregel, die prüft, ob der dem Feld zugeordnete Wert größer als Null ist. Wenn der Wert die Validierung nicht besteht, gibt Mongoose einen Fehler mit der Nachricht aus Bitte geben Sie ein gültiges Alter ein. Sie können dieses Feld leer lassen, da es nicht als gekennzeichnet ist erforderlich.

Nach der Definition des Schemas erstellt der Codeblock ein Mongoose-Modell namens Benutzer verwenden mungo.model() Methode. Diese Methode akzeptiert zwei Argumente: den Namen des Modells und das für die Dokumente zu verwendende Schema.

Endlich, das Benutzer Modell wird in andere Teile Ihrer Anwendung exportiert.

Interaktion mit MongoDB mit Mongoose

Wenn Ihre Anwendung mit einer MongoDB-Datenbank verbunden ist und Ihr Modell erstellt wurde und für andere Teile Ihrer Anwendung zugänglich ist, können Sie mithilfe der von Mongoose bereitgestellten Methoden mit Ihrer Datenbank interagieren.

Für dieses Tutorial werden Sie durchführen CRUD-Operationen auf einer MongoDB-Datenbank.

Notiz: Stellen Sie sicher, dass Sie Ihr Mongoose-Modell in jedes Modul importieren, in dem Sie die CRUD-Vorgänge ausführen.

Zum Beispiel:

//router.js
konst Benutzer = erfordern("./userModel")

Erstellen eines Dokuments

Ein Dokument ist eine Instanz eines Modells. Es gibt mehrere Möglichkeiten, wie Sie mit Mongoose ein Dokument erstellen und in MongoDB speichern können.

Zuerst können Sie eine Instanz der Klasse Ihres Modells erstellen und dann die aufrufen speichern Methode drauf.

Zum Beispiel:

//Erstellen eines neuen Benutzers
lassen Benutzer = neu Benutzer({
 Name,
 Email,
 Alter,
});
//Benutzer in Datenbank speichern
Benutzer
 .speichern()
 .Dann(() => {
Konsole.Protokoll("Benutzer erfolgreich erstellt");
 })
 .fangen((Fehler) => {
//Fehler behandeln
 });

Der obige Codeblock erstellt und speichert eine neue Benutzer Dokument in Ihre MongoDB-Datenbank.

Sie können Daten auch mit in Ihrer Datenbank speichern erstellen Methode. Der erstellen -Methode instanziiert Ihr Modell und ruft die auf speichern Methode drauf. Mit anderen Worten, es kombiniert die beiden Operationen der zuvor erwähnten Technik.

Zum Beispiel:

User.create({ Name, E-Mail, Alter }, (Fehler, Daten) => {
Wenn (irren) WurfneuFehler("Interner Serverfehler");
Konsole.Protokoll(`Benutzer erfolgreich erstellt: ${Daten}`);
 });

Der obige Codeblock erstellt eine neue Benutzer Dokument mit den Eigenschaften, die als Argument an die übergeben werden erstellen Methode.

Alternativ können Sie Daten in Ihrer Datenbank speichern, indem Sie die verwenden viele einfügen Methode. Obwohl diese Methode nur für das Speichern von Daten in Stapeln ideal ist.

Zum Beispiel:

User.insertMany(
 [
 { Name, E-Mail, Alter },
 { name_1, email_1, alter_1 },
 ],
 (err, Ergebnis) => {
Wenn (irren) {
//Fehler behandeln
 } anders {
//Ergebnisse senden
 }
 }
 );

Der obige Codeblock erstellt zwei neue Dokumente in der Benutzer Sammlung, die das Array verwendet, das als Argument an die übergeben wird viele einfügen Methode.

Lesen eines Dokuments

Mit Mongoose können Sie auf alle gespeicherten Dokumente in Ihrer MongoDB-Datenbank zugreifen finden Methode.

Zum Beispiel:

User.find({})
 .Dann((Daten) => {
Konsole.Logdaten);
 })
 .fangen((irren) => {
//Fehler behandeln
 });

Der obige Codeblock gibt alle Dokumente in der zurück Benutzer Sammlung.

Sie können auch alle Dokumente finden, die einer bestimmten Abfrage entsprechen, indem Sie eine Abfrage an die Methode find übergeben.

Zum Beispiel:

// Alle Dokumente finden, deren Alter mindestens 18 Jahre beträgt
User.find({ Alter: { $gte: 18 } })
 .Dann((Daten) =>Konsole.Logdaten))
 .fangen((Fehler) =>Konsole.log (Fehler));

Der obige Codeblock gibt alle Dokumente mit einem Alterswert größer als 18 in der zurück Benutzer Sammlung.

Alternativ können Sie einzelne Datensätze mit auslesen findById -Methode und Übergabe einer Dokument-ID als Argument oder Verwendung der einen finden -Methode und Übergeben eines Filters als Argument.

Zum Beispiel:

//findById
User.findById (id, (Fehler, Ergebnis) => {
Wenn (Ergebnis) Konsole.log (Ergebnis);
Wenn (Fehler) Konsole.error (Fehler)
 });
//findOne
User.findOne({ Email: "[email protected]" }).Dann((Benutzer) => {
Wenn (!Benutzer) {
//Fehler behandeln
 }
//Antwort senden
 });

Im obigen Codeblock ist die findById -Methode gibt das Dokument mit der übereinstimmenden ID zurück. Der einen finden -Methode gibt das erste Dokument mit der E-Mail zurück [email protected].

Aktualisieren eines Dokuments

Sie können ein Dokument in MongoDB mit Mongoose aktualisieren, indem Sie die findByIdAndUpdate Methode. Diese Methode nimmt eine ID und ein Objekt mit den aktualisierten Details.

Zum Beispiel:

User.findByIdAndUpdate (id, req.body, (err, doc) => {
Wenn (doc) {
//Antwort senden
 }
Wenn (irren) {
//Fehler behandeln
 }
});

Der obige Codeblock aktualisiert das Dokument mit einer ID, die mit der bereitgestellten ID übereinstimmt, mit dem bereitgestellten Aktualisierungsobjekt (req.body).

Löschen eines Dokuments

Sie können ein Dokument in MongoDB mit Mongoose löschen, indem Sie die findByIdAndDelete Methode. Diese Methode nimmt eine ID als Argument und löscht das Dokument mit der entsprechenden ID.

Zum Beispiel:

User.findByIdAndDelete (id, (Fehler, Ergebnis) => {
Wenn (Ergebnis) {
//Ergebnis verarbeiten
 }
Wenn (Fehler) {
//Fehler behandeln
 }
});

Der obige Codeblock löscht ein Dokument mit der angegebenen ID aus Ihrer MongoDB-Datenbank.

Verwendung von Mongoose in Ihren Express-Anwendungen

Dieser Artikel gab einen Überblick darüber, wie Sie Mongoose in Ihrer Express-Anwendung verwenden können. Beschreibt, wie Sie eine Verbindung zu MongoDB herstellen, in Ihrer MongoDB-Datenbank gespeicherte Daten strukturieren und validieren und einfache CRUD-Vorgänge durchführen können.

Durch die Verwendung von Mongoose in Ihren Express-Anwendungen können Sie die Interaktionen zwischen Ihrer Anwendung und einer MongoDB-Datenbank vereinfachen und optimieren.