Sagen Sie uns, wie wir helfen können

Vertrieb & Preise

Speak to a rep about your business needs

Vertrieb kontaktieren

Hilfe & Support

See our product support options

Support kontaktieren

Allgemeine Anfragen und Standorte

Kontakt

Beliebte Reiseziele

Wir verwenden KI-Tools, um unsere Inhalte in mehreren Sprachen bereitzustellen. Da diese Übersetzungen automatisiert sind, kann es zu Abweichungen zwischen der englischen und der übersetzten Version kommen. Die englische Version dieser Inhalte ist die offizielle Version. Kontaktieren Sie BMC, um mit einem Experten zu sprechen, der Ihre Fragen beantworten kann.

Wie man Mongoose für MongoDB und NodeJS verwendet

Wie man Mongoose für MongoDB und NodeJS verwendet

  • Orchestrierung
5 Minuten Lesezeit Aktualisiert Oct 27, 2017

Verfasst von: Walker Rowe

Auf einen Blick: Mongoose ist eine NodeJS-Bibliothek, die die Interaktion mit MongoDB vereinfacht, indem sie Datenspeicherung und Schema-Validierung ermöglicht. Der Leitfaden beschreibt Voraussetzungen einschließlich der Installation von NodeJS und bietet Schritte zur Erstellung einer Datenbank und eines Schemas sowie Beispielcode zum Laden von Daten, insbesondere mit Fokus auf einen Smokers-Datensatz.

  • Lerne, Mongoose mit MongoDB und NodeJS zu benutzen.
  • Enthält Codebeispiele zum Speichern und Überprüfen von Daten.

Hier zeigen wir, wie man Mongoose verwendet, um Daten in einer MongoDB zu speichern.

Was ist Mongoose?

In diesem Beispiel verwenden wir NodeJS. Mach dir keine Sorgen, wenn du NodeJS nicht kennst. Wir erklären jede Codezeile. Es ist serverseitiges JavaScript. Es ist anfangs etwas schwer zu verstehen, zum Teil weil es asynchron ist, also multithreaded. Du musst also entweder verwenden:

  • Nur synchrone Funktionen
  • Rückrufe

Andernfalls läuft bei Aussage n auch Aussage n+1 sofort aus. Du kannst also zum Beispiel eine Textdatei verarbeiten, bevor du sie vollständig gelesen hast.

Mongoose ist eine API auf einer API. Sie macht die Nutzung der MongoDB NodeJS API einfacher.

Voraussetzungen

Zuerst brauchst du NodeJS Version 6 oder höher. Dann installiere Mongoose so:

    npm install mongoose

Beispieldaten

Wir werden Daten zu Rauchern vom CDC (Center for Disease Control) verwenden. Laden Sie das so herunter:

    wget https://chronicdata.cdc.gov/views/wsas-xwh5

Dieser Datensatz ist eine Umfrage unter Rauchern. Wir interessieren uns nur für den Teil der Daten, der zeigt, welche Bundesstaaten die meisten Raucher haben (also bestimmte CachedContents JSON-Abschnitte). Dieser Abschnitt sieht so aus:

    {
"id" : 320867377,
"name" : "LocationDesc",
"dataTypeName" : "text",
"description" : "Location description",
"fieldName" : "locationdesc",
"position" : 3,
"renderTypeName" : "text",
"tableColumnId" : 20084901,
"width" : 109,
"cachedContents" : {
"largest" : "Wyoming",
"non_null" : 14069,
"null" : 0,
"top" : [ {
"item" : "North Carolina",
"count" : 20
}, {
"item" : "North Dakota",
"count" : 19
}, {
"item" : "Ohio",
"count" : 18

Öffnen Sie nun die MongoDB-CLI und erstellen Sie die Tabakdatenbank und die Rauchersammlung:

    mongo
use tobacco
db.createCollection("smokers")

Im Folgenden erklären wir den Code. Am Ende befindet sich das gesamte Programm, damit Sie es kopieren und einfügen können.

Zuerst verbinden wir uns mit MongoDB:

    var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/tobacco', { useMongoClient: true });
mongoose.Promise = global.Promise;

Als Nächstes erstellen wir ein Schema. Ein Schema ist nicht erforderlich. Eine Sache bei MongoDB ist, dass man jede Art von JSON hineinlegen kann und es speichert. Aber ein Schema erlaubt es, eigene Validierungsregeln zu definieren. Das Schema kann auch alle möglichen coolen Elemente wie Funktionen enthalten.

Wie Sie sehen, ist cachedContents der Teil des JSON-Dokuments, an dem wir interessiert sind. Und oben ist ein Array.

    var schema = new mongoose.Schema({
cachedContents : {
largest : String,
non_null : Number,
null : Number,
top : [{
item : String,
count : Number
}],
smallest : String,
format : {
displayStyle : String,
align : String
}
}
});

Anschließend kompilieren wir das Schema in ein Modell wie dieses:

    var Smokers = mongoose.model('smokers', schema);

Lesen Sie die JSON-String-Daten (fs.readFileSync) in ein JSON-JavaScript-Objekt (unter Verwendung von JSON.parse). Beachten Sie, dass wir fs.readFileSync (d. h. synchron) anstelle von fs.readFile verwenden, damit die nächsten Codeabschnitte warten, bis das Lesen abgeschlossen ist.

    fs = require('fs');

    var d = fs.readFileSync('/home/walker/Documents/mongodb/tobacco.json', 'utf8', (err, data) => {
if (err) throw err;
return (d); });

    var e = JSON.parse(d);

Als Nächstes kommt der komplexeste Teil. Die Tabak-JSON-Datei besteht aus zwei Ebenen von JSON. Wir haben also eine Schleife innerhalb eines Looks. Dann beziehen wir uns auf den cachedContents Teil des JSON-Objekts mit e.columns[i,j].cachedContents. Wir wollen diese Datensätze nur mit e.columns[i,j].cachedContents.top, d.h. top ist definiert. (Die anderen sind Geolokalisierungsdaten.)

Wir liefern die e.columns[i,j].cachedContents an den Konstruktor für das Smokers-Schema. Dann verwenden wir die Speichermethode . Das Speichern läuft asynchron. Aber das ist uns egal, da es am Ende des Programms kommt.

    for (i in e) {
for (j in i) {

    if (e.columns[i,j].dataTypeName != 'location') {
if (typeof(e.columns[i,j].cachedContents.top) != 'undefined') {
var smokers = new Smokers(e.columns[i,j].cachedContents);
console.log(e.columns[i,j].cachedContents);
smokers.save(function (err) {
if (err)return console.log(err);
})
}
}
}
}

Der vollständige Code

Kopiere und speichere das als loaddata.js. Dann führe es aus: Node loaddata.js. Beachte, dass es keinen Haupt- oder Ähnliches gibt. Es läuft einfach von oben nach unten.

    fs = require('fs');

    var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/tobacco', { useMongoClient: true });
mongoose.Promise = global.Promise;

    var schema = new mongoose.Schema({
cachedContents : {
largest : String,
non_null : Number,
null : Number,
top : [{
item : String,
count : Number
}],
smallest : String,
format : {
displayStyle : String,
align : String
}
}
});

    var d = fs.readFileSync('/home/walker/Documents/mongodb/tobacco.json', 'utf8', (err, data) => {
if (err) throw err;
return (d); });

    var e = JSON.parse(d);

    var Smokers = mongoose.model('smokers', schema);

    for (i in e) {
for (j in i) {

    if (e.columns[i,j].dataTypeName != 'location') {
if (typeof(e.columns[i,j].cachedContents.top) != 'undefined') {
var smokers = new Smokers(e.columns[i,j].cachedContents);
console.log(e.columns[i,j].cachedContents);
smokers.save(function (err) {
if (err)return console.log(err);
})
}
}
}
}

Der gespeicherte Eintrag sieht ungefähr so aus:

    { largest: 'Wyoming',
non_null: 14069,
null: 0,
top:
[ { item: 'North Carolina', count: 20 },
{ item: 'North Dakota', count: 19 },
{ item: 'Ohio', count: 18 },
{ item: 'Oklahoma', count: 17 },
{ item: 'Oregon', count: 16 },
{ item: 'Pennsylvania', count: 15 },
{ item: 'Puerto Rico', count: 14 },
{ item: 'Rhode Island', count: 13 },
{ item: 'South Carolina', count: 12 },
{ item: 'South Dakota', count: 11 },
{ item: 'Tennessee', count: 10 },
{ item: 'Texas', count: 9 },
{ item: 'Utah', count: 8 },
{ item: 'Vermont', count: 7 },
{ item: 'Virginia', count: 6 },
{ item: 'Washington', count: 5 },
{ item: 'West Virginia', count: 4 },
{ item: 'Wisconsin', count: 3 },
{ item: 'Wyoming', count: 2 },
{ item: 'Indiana', count: 1 } ],
smallest: 'Alabama' }

Tipps

Während du damit arbeitest, kannst du Objekte löschen und dann wie unten gezeigt anzeigen. Entfernen erfordert einen Filter. {} ist ein Filter, also alle Datensätze. Du verwendest db statt tobacco, um die Datenbank zu kennzeichnen. Und smokers ist die Sammlung. Und wenn du etwas falsch schreibst, ergibt es keinen Fehler, da es davon ausgeht, dass du ein neues Objekt erstellen möchtest. (JavaScript ist auch so, da es keine Fehlerprüfung bezüglich der Rechtschreibung von Variablennamen hat.)

    sse tobacco
db.smokers.remove({})
db.smokers.find({}).pretty()

Und dann kannst du die Daten so mit dem interaktiven Node-Interpreter durchgehen (d. h. Node ausführen und dann den Code einfügen, den du untersuchen möchtest:

    for (i in e) { for (j in i) {"i=",i,"j=",j,console.log(e.columns[i,j].cachedContents) }}

Zusätzliche Ressourcen

play

Mongoose: MongoDB-Objektmodellierung für Node.js von Yuriy Bogomolov

MongoDB-Leitfaden

  1. MongoDB-Überblick: Einstieg mit MongoDB
  2. Wie man MongoDB auf Ubuntu und Mac installiert
  3. Erstellung einer Datenbank in MongoDB
  4. MongoDB Shell Grundbefehle
  5. MongoDB Compass: Nutzung der Mongo GUI
  6. MongoDB rollenbasierte Zugriffskontrolle (RBAC) erklärt
  7. MongoDB-Projektion und Projektionsoperatoren erklärt
  8. MongoDB-Aggregatfunktionen erklärt
  9. MongoDB-Sortierung: sort()-Methode & Beispiele
  10. Verwendung von Push-and-Pull-Operatoren in MongoDB
  11. Wie man MongoDB $unwind
  12. 23 Gängige MongoDB-Abfrageoperatoren und deren Verwendung
  13. MongoDB GeoLocation-Abfragebeispiele
  14. Einführung in MongoDB-Transaktionen
  15. MongoDB-Indizes: Top-Indextypen und deren Verwaltung
  16. Die wichtigsten MongoDB-Befehle, die du kennen solltest
  17. MongoDB-Replikation: Eine vollständige Einführung
  18. Wie man einen MongoDB-Cluster einrichtet
  19. MongoDB Sharding: Konzepte, Beispiele & Tutorials
  20. MongoDB Atlas: Einrichtung und Nutzung von verwaltetem MongoDB
  21. Wie man MongoDB als Docker-Container ausführt
  22. MongoDB-Speichernutzung, Verwaltung und Anforderungen
  23. Wie man Mongodump für MongoDB-Backups verwendet
  24. Mongorestore-Beispiele zur Wiederherstellung von MongoDB-Backups
  25. Wie man PyMongo benutzt
  26. Wie man Mongoose für MongoDB und NodeJS verwendet
  27. MongoDB Spickzettel
  28. MongoDB vs Cassandra: NoSQL-Datenbanken im Vergleich
  29. PostgreSQL vs MongoDB: Vergleich von Datenbanken
  30. MySQL vs. MongoDB: Vergleich von Datenbanken
  31. MongoDB-Zertifizierungen: Eine Einführung

Diese Beiträge sind meine eigenen und spiegeln nicht unbedingt die Position, Strategien oder Meinung von BMC wider.

Mehr aus Orchestrierung

Abonnieren Sie The Brief

Mit der Registrierung für dieses Angebot bestätigen Sie, dass Sie die Datenschutzrichtlinie von BMC gelesen und zugestimmt haben.

Danke

Sie haben The Brief abonniert
Das Briefing umfasst die Mainframe- und Enterprise-Orchestrierung – BMC AMI und Control-M – sowie die Analystenforschung, Kundeneinsätze und Events in beiden Bereichen.

Lesen Sie Ausgabe 01 Entdecken Sie BMC