Node.js: Verbindung zu MongoDB herstellen
MongoDB ist ein dokumentenorientiertes Datenbankverwaltungssystem, geschrieben in C++.
In diesem Kapitel zeigen wir, wie Sie Node.js verwenden, um eine Verbindung zu MongoDB herzustellen und Datenbankoperationen auszuführen.
Wenn Sie noch keine Grundkenntnisse über MongoDB haben, können Sie sich auf unser Tutorial beziehen:MongoDB-Tutorial。
Treiber installieren
Dieses Tutorial verwendet denvon Taobao angepassten cnpm-Befehlzur Installation:
$ cnpm install mongodb
Nach erfolgreicher Installation können wir das MongoClient-Objekt verwenden, um eine Verbindung zur Datenbank herzustellen:
Beispiel
const { MongoClient } = require('mongodb');
async function main() {
// MongoDB-Verbindungs-URI
const uri = "mongodb://localhost:27017"; // Wenn Sie eine Remote-MongoDB verwenden, ändern Sie die URI entsprechend
// Einen neuen MongoClient erstellen
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
try {
// Verbindung zum MongoDB-Server herstellen
await client.connect();
console.log("Erfolgreich mit dem Server verbunden");
} finally {
// Stellen Sie sicher, dass die Verbindung nach Abschluss geschlossen wird
await client.close();
}
}
main().catch(console.error);
async function main() {
// MongoDB-Verbindungs-URI
const uri = "mongodb://localhost:27017"; // Wenn Sie eine Remote-MongoDB verwenden, ändern Sie die URI entsprechend
// Einen neuen MongoClient erstellen
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
try {
// Verbindung zum MongoDB-Server herstellen
await client.connect();
console.log("Erfolgreich mit dem Server verbunden");
} finally {
// Stellen Sie sicher, dass die Verbindung nach Abschluss geschlossen wird
await client.close();
}
}
main().catch(console.error);
Das Ausführen des obigen Codes erzeugt die folgende Ausgabe:
Connected successfully to server
Beschreibung der Verbindungsparameter:
MongoClient: Dies ist der MongoDB-Client, mit dem eine Verbindung zur Datenbank hergestellt wird.uri: Dies ist die MongoDB-Verbindungszeichenfolge im Formatmongodb://[username:password@]host1[:port1][,...hostN[:portN]][/[defaultauthdb][?options]]。useNewUrlParserunduseUnifiedTopologysind einige Optionen, mit denen sich einige alte Verbindungsverhalten vermeiden lassen.
Als Nächstes implementieren wir die Funktionen zum Erstellen, Lesen, Aktualisieren und Löschen (CRUD).
Datenbank erstellen
Um eine Datenbank in MongoDB zu erstellen, müssen wir zuerst ein MongoClient-Objekt erstellen und dann die angegebene URL und Portnummer konfigurieren.
Wenn die Datenbank nicht existiert, erstellt MongoDB die Datenbank und stellt die Verbindung her.
Verbindung erstellen
const { MongoClient } = require('mongodb');
async function main() {
//MongoDB-Verbindungs-URI
const uri = "mongodb://localhost:27017"; //Bitte passen Sie es an die Adresse Ihres MongoDB-Servers an
//Erstellen Sie einen neuen MongoClient
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
try {
//Verbindung zum MongoDB-Server herstellen
await client.connect();
console.log("Erfolgreich mit dem Server verbunden");
//Datenbank angeben
const database = client.db('example');
//Hier können Sie Datenbankoperationen ausführen, wie das Erstellen einer Collection oder das Einfügen von Dokumenten
const collection = database.collection('exampleCollection');
const doc = { name: "Example", type: "Test" };
const result = await collection.insertOne(doc);
console.log(`Neues Dokument erstellt,IDist: ${result.insertedId}`);
} finally {
//Achten Sie darauf, die Verbindung zu schließen, wenn Sie fertig sind
await client.close();
}
}
main().catch(console.error);
Das Ausführen des obigen Codes erzeugt die folgende Ausgabe:
成功连接到服务器 新文档已创建，ID 为: 6678e18e0bb3f4247be610d8
Sammlung erstellen
Wir können die createCollection()-Methode verwenden, um eine Collection zu erstellen:
Sammlung erstellen
const { MongoClient } = require('mongodb');
async function main() {
//MongoDB-Verbindungs-URI
const uri = "mongodb://localhost:27017"; //Bitte passen Sie es an die Adresse Ihres MongoDB-Servers an
//Erstellen Sie einen neuen MongoClient
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
try {
//Verbindung zum MongoDB-Server herstellen
await client.connect();
console.log("Erfolgreich mit dem Server verbunden");
//Datenbank angeben
const database = client.db('example');
//Verwenden Sie die createCollection-Methode, um eine Collection zu erstellen
const collectionName = 'exampleCollection';
await database.createCollection(collectionName);
console.log(`Sammlung ${collectionName}erfolgreich erstellt`);
//Sammlung abrufen
const collection = database.collection(collectionName);
//Neues Dokument erstellen
const doc = { name: "Example", type: "Test" };
//Ein Dokument in die Sammlung einfügen
const result = await collection.insertOne(doc);
console.log(`Neues Dokument erstellt,IDist: ${result.insertedId}`);
} finally {
//Achten Sie darauf, die Verbindung nach Abschluss zu schließen
await client.close();
}
}
main().catch(console.error);
Das Ausführen des obigen Codes erzeugt die folgende Ausgabe:
成功连接到服务器 集合 exampleCollection 创建成功 新文档已创建，ID 为: 6678e1b5c742b3ebd57f9759
Datenbankoperationen (CRUD)
Im Gegensatz zu MySQL erstellt MongoDB Datenbanken und Sammlungen automatisch, sodass wir sie nicht manuell vor der Verwendung erstellen müssen.
Daten einfügen
In the following example, we connect to the exampleCollection table in the example database and insert a piece of data, using insertOne() verwenden：
Ein Dokument einfügen
const { MongoClient } = require('mongodb');
async function main() {
//MongoDB-Verbindungs-URI
const uri = "mongodb://localhost:27017"; //Bitte passen Sie es an die Adresse Ihres MongoDB-Servers an
//Erstellen Sie einen neuen MongoClient
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
try {
//Verbindung zum MongoDB-Server herstellen
await client.connect();
console.log("Erfolgreich mit dem Server verbunden");
//Datenbank angeben
const database = client.db('example');
//Verwenden Sie die createCollection-Methode, um eine Collection zu erstellen
const collectionName = 'exampleCollection';
await database.createCollection(collectionName);
console.log(`Sammlung ${collectionName}erfolgreich erstellt`);
//Sammlung abrufen
const collection = database.collection(collectionName);
//Neues Dokument erstellen
const doc = { name: "Alice", age: 25, address: "Wonderland" };
//Ein Dokument in die Sammlung einfügen
const result = await collection.insertOne(doc);
console.log(`Neues Dokument erstellt,IDist: ${result.insertedId}`);
} finally {
//Achten Sie darauf, die Verbindung zu schließen, wenn Sie fertig sind
await client.close();
}
}
main().catch(console.error);
Führen Sie den folgenden Befehl aus, und das Ausgabeergebnis lautet:
成功连接到服务器 集合 exampleCollection 创建成功 新文档已创建，ID 为: 6678e1d1f9503dc2e0e2a20b
Aus dem Ausgabeergebnis geht hervor, dass die Daten erfolgreich eingefügt wurden.
Wir können auch den MongoDB-Client öffnen, um die Daten anzuzeigen, wie folgt:
> show dbs
example 0.000GB # 创建了 example 数据库
> use example # 切换到 example 数据库
example> show tables
exampleCollection # 创建了 exampleCollection 集合（数据表）
# 自动创建了 site 集合（数据表）
example> db.exampleCollection.find()
[
{
_id: ObjectId('6678e1d1f9503dc2e0e2a20b'),
name: 'Alice',
age: 25,
address: 'Wonderland'
}
]
Wenn Sie mehrere Dokumente einfügen möchten, können SieinsertMany() verwenden：
Mehrere Dokumente einfügen
const { MongoClient } = require('mongodb');
async function main() {
//MongoDB-Verbindungs-URI
const uri = "mongodb://localhost:27017"; //Bitte passen Sie es an die Adresse Ihres MongoDB-Servers an
//Erstellen Sie einen neuen MongoClient
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
try {
//Verbindung zum MongoDB-Server herstellen
await client.connect();
console.log("Erfolgreich mit dem Server verbunden");
//Datenbank angeben
const database = client.db('example');
//Verwenden Sie die createCollection-Methode, um eine Collection zu erstellen
const collectionName = 'exampleCollection';
await database.createCollection(collectionName);
console.log(`Sammlung ${collectionName}erfolgreich erstellt`);
//Sammlung abrufen
const collection = database.collection(collectionName);
//Mehrere neue Dokumente erstellen
const docs = [
{ name: "Alice", age: 25, address: "Wonderland" },
{ name: "Bob", age: 30, address: "Builderland" },
{ name: "Charlie", age: 35, address: "Chocolate Factory" }
];
//Mehrere Dokumente in die Sammlung einfügen
const result = await collection.insertMany(docs);
console.log(`${result.insertedCount}neue Dokumente erstellt,IDist:`);
Object.keys(result.insertedIds).forEach((key, index) => {
console.log(`Dokument ${index + 1}: ${result.insertedIds[key]}`);
});
} finally {
//Achten Sie darauf, die Verbindung nach Abschluss zu schließen
await client.close();
}
}
main().catch(console.error);
Das Ausführungsergebnis ist:
成功连接到服务器 集合 exampleCollection 创建成功 3 个新文档已创建，ID 为: 文档 1: 6678e30e80ac30e5e689f13a 文档 2: 6678e30e80ac30e5e689f13b 文档 3: 6678e30e80ac30e5e689f13c
Daten abfragen
Sie können find() verwenden, um nach Daten zu suchen. find() kann alle Daten zurückgeben, die den Bedingungen entsprechen. Wenn keine Bedingungen angegeben sind, gibt find() alle Daten in der Sammlung zurück.
find()
const { MongoClient } = require('mongodb');
async function main() {
//MongoDB-Verbindungs-URI
const uri = "mongodb://localhost:27017"; //Bitte passen Sie es an die Adresse Ihres MongoDB-Servers an
//Erstellen Sie einen neuen MongoClient
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
try {
//Verbindung zum MongoDB-Server herstellen
await client.connect();
console.log("Erfolgreich mit dem Server verbunden");
//Datenbank angeben
const database = client.db('example');
//Verwenden Sie die createCollection-Methode, um eine Collection zu erstellen
const collectionName = 'exampleCollection';
await database.createCollection(collectionName);
console.log(`Sammlung ${collectionName}erfolgreich erstellt`);
//Sammlung abrufen
const collection = database.collection(collectionName);
//Mehrere neue Dokumente erstellen
const docs = [
{ name: "Alice", age: 25, address: "Wonderland" },
{ name: "Bob", age: 30, address: "Builderland" },
{ name: "Charlie", age: 35, address: "Chocolate Factory" }
];
//Mehrere Dokumente in die Sammlung einfügen
const result = await collection.insertMany(docs);
console.log(`${result.insertedCount}neue Dokumente erstellt,IDist:`);
Object.keys(result.insertedIds).forEach((id, index) => {
console.log(`Dokument ${index + 1}: ${id}`);
});
//Alle Dokumente in der Sammlung abfragen
const query = {}; //Ein leeres Abfrageobjekt bedeutet, alle Dokumente abzufragen.
const options = { projection: { _id: 0, name: 1, age: 1, address: 1 } }; //Nur die erforderlichen Felder auswählen
const cursor = collection.find(query, options);
//Alle abgefragten Dokumente ausgeben
const allValues = await cursor.toArray();
console.log("Abgefragte Dokumente:");
console.log(allValues);
} finally {
//Achten Sie darauf, die Verbindung nach Abschluss zu schließen
await client.close();
}
}
main().catch(console.error);
Das Ausführungsergebnis ist:
成功连接到服务器
集合 exampleCollection 创建成功
3 个新文档已创建，ID 为:
文档 1: 0
文档 2: 1
文档 3: 2
查询到的文档:
[
{ name: 'Alice', age: 25, address: 'Wonderland' },
{ name: 'Bob', age: 30, address: 'Builderland' },
{ name: 'Charlie', age: 35, address: 'Chocolate Factory' }
]
Das folgende Beispiel ruft Instanzen ab, bei denen name "Alice" ist:
Daten mit angegebenen Bedingungen abfragen
const { MongoClient } = require('mongodb');
async function main() {
//MongoDB-Verbindungs-URI
const uri = "mongodb://localhost:27017"; //Bitte passen Sie es an die Adresse Ihres MongoDB-Servers an
//Erstellen Sie einen neuen MongoClient
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
try {
//Verbindung zum MongoDB-Server herstellen
await client.connect();
console.log("Erfolgreich mit dem Server verbunden");
//Datenbank angeben
const database = client.db('example');
//Verwenden Sie die createCollection-Methode, um eine Collection zu erstellen
const collectionName = 'exampleCollection';
await database.createCollection(collectionName);
console.log(`Sammlung ${collectionName}erfolgreich erstellt`);
//Sammlung abrufen
const collection = database.collection(collectionName);
//Mehrere neue Dokumente erstellen
const docs = [
{ name: "Alice", age: 25, address: "Wonderland" },
{ name: "Bob", age: 30, address: "Builderland" },
{ name: "Charlie", age: 35, address: "Chocolate Factory" }
];
//Mehrere Dokumente in die Sammlung einfügen
const result = await collection.insertMany(docs);
console.log(`${result.insertedCount}neue(s) Dokument(e) wurde(n) erstellt,IDals: `);
Object.keys(result.insertedIds).forEach((id, index) => {
console.log(`document ${index + 1}: ${id}`);
});
//Dokumente mithilfe des name-Parameters abfragen
const query = { name: "Alice" }; //Suchkriterien
const options = { projection: { _id: 0, name: 1, age: 1, address: 1 } }; //Nur die erforderlichen Felder auswählen
const cursor = collection.find(query, options);
//Die abgefragten Dokumente ausgeben
const allValues = await cursor.toArray();
console.log("Abgefragte Dokumente:");
console.log(allValues);
} finally {
//Stellen Sie sicher, dass die Verbindung geschlossen wird, wenn Sie fertig sind
await client.close();
}
}
main().catch(console.error);
Die Ausgabe nach Ausführung des folgenden Befehls ist:
成功连接到服务器
集合 exampleCollection 创建成功
3 个新文档已创建，ID 为:
文档 1: 0
文档 2: 1
文档 3: 2
查询到的文档:
[
{ name: 'Alice', age: 25, address: 'Wonderland' }
]
Daten aktualisieren
Wir können auch Daten in der Datenbank ändern. Das folgende Beispiel aktualisiert die Daten, bei denen name 'Alice' ist:
Ein Dokument aktualisieren
const { MongoClient } = require('mongodb');
async function main() {
//MongoDB-Verbindungs-URI
const uri = "mongodb://localhost:27017"; //Bitte passen Sie es an die Adresse Ihres MongoDB-Servers an
//Erstellen Sie einen neuen MongoClient
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
try {
//Verbindung zum MongoDB-Server herstellen
await client.connect();
console.log("Erfolgreich mit dem Server verbunden");
//Datenbank angeben
const database = client.db('example');
//Erstellen Sie eine Collection mit der Methode createCollection
const collectionName = 'exampleCollection';
await database.createCollection(collectionName);
console.log(`Collection ${collectionName}erfolgreich erstellt`);
//Sammlung abrufen
const collection = database.collection(collectionName);
//Mehrere neue Dokumente erstellen
const docs = [
{ name: "Alice", age: 25, address: "Wonderland" },
{ name: "Bob", age: 30, address: "Builderland" },
{ name: "Charlie", age: 35, address: "Chocolate Factory" }
];
//Mehrere Dokumente in die Sammlung einfügen
const result = await collection.insertMany(docs);
console.log(`${result.insertedCount}neue(s) Dokument(e) wurde(n) erstellt,IDals: `);
Object.keys(result.insertedIds).forEach((id, index) => {
console.log(`document ${index + 1}: ${id}`);
});
//Bedingungen angeben, Daten basierend auf dem Parameter name aktualisieren
const filter = { name: "Alice" }; //Suchkriterien
const updateDoc = {
$set: {
age: 28,
address: "New Wonderland"
},
};
const updateResult = await collection.updateOne(filter, updateDoc);
console.log(`${updateResult.matchedCount}Dokument(e) entsprachen den Filterkriterien`);
console.log(`${updateResult.modifiedCount}Dokument(e) wurden aktualisiert`);
//Die aktualisierten Dokumente abfragen
const updatedDocument = await collection.findOne(filter);
console.log("Aktualisierte Dokumente:");
console.log(updatedDocument);
} finally {
//Stellen Sie sicher, dass die Verbindung geschlossen wird, wenn Sie fertig sind
await client.close();
}
}
main().catch(console.error);
Nach erfolgreicher Ausführung sieht die Ausgabe wie folgt aus:
成功连接到服务器
集合 exampleCollection 创建成功
3 个新文档已创建，ID 为:
文档 1: 0
文档 2: 1
文档 3: 2
1 个文档匹配筛选条件
1 个文档已更新
更新后的文档:
{
_id: new ObjectId('6678e1d1f9503dc2e0e2a20b'),
name: 'Alice',
age: 28,
address: 'New Wonderland'
}
Wenn Sie alle Dokumente aktualisieren möchten, die den Kriterien entsprechen, können SieupdateMany() verwenden：
Mehrere Dokumente aktualisieren
const { MongoClient } = require('mongodb');
async function main() {
//MongoDB-Verbindungs-URI
const uri = "mongodb://localhost:27017"; //Bitte passen Sie es an die Adresse Ihres MongoDB-Servers an
//Erstellen Sie einen neuen MongoClient
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
try {
//Verbindung zum MongoDB-Server herstellen
await client.connect();
console.log("Erfolgreich mit dem Server verbunden");
//Datenbank angeben
const database = client.db('example');
//Erstellen Sie eine Collection mit der Methode createCollection
const collectionName = 'exampleCollection';
await database.createCollection(collectionName);
console.log(`Collection ${collectionName}erfolgreich erstellt`);
//Sammlung abrufen
const collection = database.collection(collectionName);
//Mehrere neue Dokumente erstellen
const docs = [
{ name: "Alice", age: 25, address: "Wonderland" },
{ name: "Bob", age: 30, address: "Builderland" },
{ name: "Alice", age: 28, address: "Altes Wunderland" }
];
//Mehrere Dokumente in die Sammlung einfügen
const result = await collection.insertMany(docs);
console.log(`${result.insertedCount}neue(s) Dokument(e) wurde(n) erstellt,IDals: `);
Object.keys(result.insertedIds).forEach((id, index) => {
console.log(`document ${index + 1}: ${id}`);
});
//Bedingungen angeben, mehrere Dokumente anhand des name-Parameters aktualisieren
const filter = { name: "Alice" }; //Suchkriterien
const updateDoc = {
$set: {
address: "Aktualisiertes Wunderland"
},
};
const updateResult = await collection.updateMany(filter, updateDoc);
console.log(`${updateResult.matchedCount}Dokument(e) entsprachen den Filterkriterien`);
console.log(`${updateResult.modifiedCount}Dokument(e) wurden aktualisiert`);
//Die aktualisierten Dokumente abfragen
const updatedDocuments = await collection.find(filter).toArray();
console.log("Aktualisierte Dokumente:");
console.log(updatedDocuments);
} finally {
//Stellen Sie sicher, dass die Verbindung geschlossen wird, wenn Sie fertig sind
await client.close();
}
}
main().catch(console.error);
Daten löschen
Das folgende Beispiel löscht die Daten, bei denen name Alice ist:
Ein Dokument löschen
const { MongoClient } = require('mongodb');
async function main() {
//MongoDB-Verbindungs-URI
const uri = "mongodb://localhost:27017"; //Bitte passen Sie es an die Adresse Ihres MongoDB-Servers an
//Erstellen Sie einen neuen MongoClient
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
try {
//Verbindung zum MongoDB-Server herstellen
await client.connect();
console.log("Erfolgreich mit dem Server verbunden");
//Datenbank angeben
const database = client.db('example');
//Erstellen Sie eine Collection mit der Methode createCollection
const collectionName = 'exampleCollection';
await database.createCollection(collectionName);
console.log(`Collection ${collectionName}erfolgreich erstellt`);
//Sammlung abrufen
const collection = database.collection(collectionName);
//Mehrere neue Dokumente erstellen
const docs = [
{ name: "Alice", age: 25, address: "Wonderland" },
{ name: "Bob", age: 30, address: "Builderland" },
{ name: "Charlie", age: 35, address: "Chocolate Factory" }
];
//Mehrere Dokumente in die Sammlung einfügen
const result = await collection.insertMany(docs);
console.log(`${result.insertedCount}neue(s) Dokument(e) wurde(n) erstellt,IDals: `);
Object.keys(result.insertedIds).forEach((id, index) => {
console.log(`document ${index + 1}: ${id}`);
});
//Bedingungen angeben, ein Dokument anhand des name-Parameters löschen
const filter = { name: "Alice" }; //Suchkriterien
const deleteResult = await collection.deleteOne(filter);
console.log(`${deleteResult.deletedCount}Dokument(e) wurden gelöscht`);
//Alle Dokumente in der Sammlung abfragen, um die Löschung zu bestätigen
const remainingDocuments = await collection.find({}).toArray();
console.log("Verbleibende Dokumente:");
console.log(documentDocuments);
} finally {
//Stellen Sie sicher, dass die Verbindung geschlossen wird, wenn Sie fertig sind
await client.close();
}
}
main().catch(console.error);
Nach erfolgreicher Ausführung lautet die Ausgabe:
成功连接到服务器
集合 exampleCollection 创建成功
3 个新文档已创建，ID 为:
文档 1: 0
文档 2: 1
文档 3: 2
1 个文档已删除
剩余的文档:
[
{
_id: new ObjectId('6678e18e0bb3f4247be610d8'),
name: 'Example',
type: 'Test'
},
...
Wenn Sie mehrere Dokumente löschen möchten, können Sie diedeleteMany()Methode verwenden
Das folgende Beispiel löscht alle Daten, bei denen type 'en' ist:
Mehrere Dokumente löschen
const { MongoClient } = require('mongodb');
async function main() {
//MongoDB-Verbindungs-URI
const uri = "mongodb://localhost:27017"; //Bitte passen Sie es an die Adresse Ihres MongoDB-Servers an
//Erstellen Sie einen neuen MongoClient
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
try {
//Verbindung zum MongoDB-Server herstellen
await client.connect();
console.log("Erfolgreich mit dem Server verbunden");
//Datenbank angeben
const database = client.db('example');
//Erstellen Sie eine Collection mit der Methode createCollection
const collectionName = 'exampleCollection';
await database.createCollection(collectionName);
console.log(`Collection ${collectionName}erfolgreich erstellt`);
//Sammlung abrufen
const collection = database.collection(collectionName);
//Mehrere neue Dokumente erstellen
const docs = [
{ name: "Alice", age: 25, address: "Wonderland" },
{ name: "Alice", age: 28, address: "Old Wonderland" },
{ name: "Bob", age: 30, address: "Builderland" },
{ name: "Charlie", age: 35, address: "Chocolate Factory" }
];
//Mehrere Dokumente in die Sammlung einfügen
const result = await collection.insertMany(docs);
console.log(`${result.insertedCount}neue(s) Dokument(e) wurde(n) erstellt,IDals: `);
Object.keys(result.insertedIds).forEach((id, index) => {
console.log(`document ${index + 1}: ${id}`);
});
//Bedingungen angeben, mehrere Dokumente basierend auf dem name-Parameter löschen
const filter = { name: "Alice" }; //Suchkriterien
const deleteResult = await collection.deleteMany(filter);
console.log(`${deleteResult.deletedCount}Dokument(e) wurden gelöscht`);
//Alle Dokumente in der Sammlung abfragen, um die Löschung zu bestätigen
const remainingDocuments = await collection.find({}).toArray();
console.log("Verbleibende Dokumente:");
console.log(remainingDocuments);
} finally {
//Stellen Sie sicher, dass die Verbindung geschlossen wird, wenn Sie fertig sind
await client.close();
}
}
main().catch(console.error);
Sort
Zum Sortieren wird die Methode sort() verwendet, die einen Parameter akzeptiert, der angibt, ob die Reihenfolge aufsteigend (1) oder absteigend (-1) ist.
Zum Beispiel:
{ type: 1 } // 按 type 字段升序
{ type: -1 } // 按 type 字段降序
Nach type in aufsteigender Reihenfolge sortieren:
Sortierung
const { MongoClient } = require('mongodb');
async function main() {
//MongoDB-Verbindungs-URI
const uri = "mongodb://localhost:27017"; //Bitte passen Sie es an die Adresse Ihres MongoDB-Servers an
//Erstellen Sie einen neuen MongoClient
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
try {
//Verbindung zum MongoDB-Server herstellen
await client.connect();
console.log("Erfolgreich mit dem Server verbunden");
//Datenbank angeben
const database = client.db('example');
//Erstellen Sie eine Collection mit der Methode createCollection
const collectionName = 'exampleCollection';
await database.createCollection(collectionName);
console.log(`Collection ${collectionName}erfolgreich erstellt`);
//Sammlung abrufen
const collection = database.collection(collectionName);
//Mehrere neue Dokumente erstellen
const docs = [
{ name: "Alice", age: 25, address: "Wonderland" },
{ name: "Bob", age: 30, address: "Builderland" },
{ name: "Charlie", age: 35, address: "Chocolate Factory" },
{ name: "Dave", age: 20, address: "Dreamland" }
];
//Mehrere Dokumente in die Sammlung einfügen
const result = await collection.insertMany(docs);
console.log(`${result.insertedCount}neue(s) Dokument(e) wurde(n) erstellt,IDals: `);
Object.keys(result.insertedIds).forEach((id, index) => {
console.log(`document ${index + 1}: ${id}`);
});
//Sortiere die Dokumente mit der Methode sort()
//Nach dem Feld age in aufsteigender Reihenfolge sortieren
const sortedDocsAsc = await collection.find().sort({ age: 1 }).toArray();
console.log("Nach dem Feld age in aufsteigender Reihenfolge sortierte Dokumente:");
console.log(sortedDocsAsc);
//Nach dem Feld age in absteigender Reihenfolge sortieren
const sortedDocsDesc = await collection.find().sort({ age: -1 }).toArray();
console.log("Dokumente, sortiert nach dem Feld age in absteigender Reihenfolge:");
console.log(sortedDocsDesc);
} finally {
//Stellen Sie sicher, dass die Verbindung geschlossen wird, wenn Sie fertig sind
await client.close();
}
}
main().catch(console.error);
Abfrage-Paginierung
Wenn Sie die Anzahl der zurückgegebenen Dokumente festlegen möchten, können Sie dielimit()-Methode verwenden, die nur einen Parameter akzeptiert, der die Anzahl der zurückzugebenden Dokumente angibt.
limit(): Zwei Dokumente lesen
const { MongoClient } = require('mongodb');
async function main() {
//MongoDB-Verbindungs-URI
const uri = "mongodb://localhost:27017"; //Bitte passen Sie es an die Adresse Ihres MongoDB-Servers an
//Erstellen Sie einen neuen MongoClient
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
try {
//Verbindung zum MongoDB-Server herstellen
await client.connect();
console.log("Erfolgreich mit dem Server verbunden");
//Datenbank angeben
const database = client.db('example');
//Erstellen Sie eine Collection mit der Methode createCollection
const collectionName = 'exampleCollection';
await database.createCollection(collectionName);
console.log(`Collection ${collectionName}erfolgreich erstellt`);
//Sammlung abrufen
const collection = database.collection(collectionName);
//Mehrere neue Dokumente erstellen
const docs = [
{ name: "Alice", age: 25, address: "Wonderland" },
{ name: "Bob", age: 30, address: "Builderland" },
{ name: "Charlie", age: 35, address: "Chocolate Factory" },
{ name: "Dave", age: 20, address: "Dreamland" },
{ name: "Eve", age: 22, address: "Eden" }
];
//Mehrere Dokumente in die Sammlung einfügen
const result = await collection.insertMany(docs);
console.log(`${result.insertedCount}neue(s) Dokument(e) wurde(n) erstellt,IDals: `);
Object.keys(result.insertedIds).forEach((id, index) => {
console.log(`document ${index + 1}: ${id}`);
});
//Verwenden Sie die limit()-Methode, um die Anzahl der Abfrageergebnisse zu begrenzen
const limitedDocs = await collection.find().limit(3).toArray();
console.log("Die Abfrageergebnisse auf 3 Dokumente begrenzen:");
console.log(limitedDocs);
} finally {
//Stellen Sie sicher, dass die Verbindung geschlossen wird, wenn Sie fertig sind
await client.close();
}
}
main().catch(console.error);
Wenn Sie die Anzahl der zu überspringenden Dokumente angeben möchten, können Sie dieskip()-Methode verwenden.
Die skip()-Methode wird verwendet, um eine angegebene Anzahl von Dokumenten zu überspringen und die Abfrageergebnisse der verbleibenden Dokumente zurückzugeben.
skip(): Überspringen Sie die ersten beiden Dokumente und lesen Sie zwei Dokumente
const { MongoClient } = require('mongodb');
async function main() {
//MongoDB-Verbindungs-URI
const uri = "mongodb://localhost:27017"; //Bitte passen Sie es an die Adresse Ihres MongoDB-Servers an
//Erstellen Sie einen neuen MongoClient
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
try {
//Verbindung zum MongoDB-Server herstellen
await client.connect();
console.log("Erfolgreich mit dem Server verbunden");
//Datenbank angeben
const database = client.db('example');
//Erstellen Sie eine Collection mit der Methode createCollection
const collectionName = 'exampleCollection';
await database.createCollection(collectionName);
console.log(`Collection ${collectionName}erfolgreich erstellt`);
//Sammlung abrufen
const collection = database.collection(collectionName);
//Mehrere neue Dokumente erstellen
const docs = [
{ name: "Alice", age: 25, address: "Wonderland" },
{ name: "Bob", age: 30, address: "Builderland" },
{ name: "Charlie", age: 35, address: "Chocolate Factory" },
{ name: "Dave", age: 20, address: "Dreamland" },
{ name: "Eve", age: 22, address: "Eden" }
];
//Mehrere Dokumente in die Sammlung einfügen
const result = await collection.insertMany(docs);
console.log(`${result.insertedCount}neue(s) Dokument(e) wurde(n) erstellt,IDals: `);
Object.keys(result.insertedIds).forEach((id, index) => {
console.log(`document ${index + 1}: ${id}`);
});
//Verwenden Sie die skip()-Methode, um die ersten beiden Dokumente zu überspringen und die verbleibenden Dokumente zurückzugeben
const skippedDocs = await collection.find().skip(2).toArray();
console.log("Abfrageergebnisse nach dem Überspringen der ersten beiden Dokumente:");
console.log(skippedDocs);
} finally {
//Stellen Sie sicher, dass die Verbindung geschlossen wird, wenn Sie fertig sind
await client.close();
}
}
main().catch(console.error);
Verbindungsoperation
mongoDB ist keine relationale Datenbank, aber wir können$lookupverwenden, um einen Left Join zu implementieren.
$lookup ist ein Aggregations-Pipeline-Operator in MongoDB, der verwendet wird, um Left Outer Joins durchzuführen. Er kann verwendet werden, um Dokumente in einer Sammlung zu finden, die den Bedingungen in einer anderen Sammlung entsprechen, und sie zusammenzuführen.
Zum Beispiel haben wir zwei Sammlungen mit folgenden Daten:
Sammlung 1: orders
[
{ "_id": 1, "product_id": 101, "quantity": 2 },
{ "_id": 2, "product_id": 102, "quantity": 1 },
{ "_id": 3, "product_id": 103, "quantity": 4 }
]
Sammlung 2: products
[
{ "_id": 101, "name": "Product A", "price": 50 },
{ "_id": 102, "name": "Product B", "price": 70 },
{ "_id": 103, "name": "Product C", "price": 100 },
{ "_id": 104, "name": "Product D", "price": 120 }
]
Jetzt möchten wir die $lookup-Operation verwenden, um das Feld product_id in der orders-Sammlung mit dem Feld _id in der products-Sammlung zu verknüpfen und detaillierte Produktinformationen für jede Bestellung zu erhalten.
Im Folgenden wird ein MongoDB-Aggregationsbeispiel gezeigt, das diese Funktionalität implementiert:
Beispiel
const { MongoClient } = require('mongodb');
async function main() {
//MongoDB-Verbindungs-URI
const uri = "mongodb://localhost:27017"; //Bitte passen Sie es an die Adresse Ihres MongoDB-Servers an
//Erstellen Sie einen neuen MongoClient
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
try {
//Verbindung zum MongoDB-Server herstellen
await client.connect();
console.log("Erfolgreich mit dem Server verbunden");
//Datenbank angeben
const database = client.db('mydatabase');
//orders-Sammlung
const ordersCollection = database.collection('orders');
//products-Sammlung
const productsCollection = database.collection('products');
//Definieren Sie die Aggregationspipeline und verwenden Sie $lookup, um einen Left Outer Join durchzuführen
const pipeline = [
{
$lookup: {
from: 'products', //Der Name der Sammlung, die verknüpft werden soll
localField: 'product_id', //Das Feld aus der lokalen Sammlung, das abgeglichen werden soll
foreignField: '_id', //Das Feld aus der verknüpften Sammlung, das abgeglichen werden soll
as: 'productDetails' //Der Feldname, der in die Ausgabeergebnisse aufgenommen werden soll
}
}
];
//Die Aggregationsoperation ausführen
const result = await ordersCollection.aggregate(pipeline).toArray();
//Die Abfrageergebnisse ausgeben
console.log("Ergebnisse der Left-Outer-Join-Abfrage:");
console.log(result);
} finally {
//Achten Sie darauf, die Verbindung nach Abschluss zu schließen
await client.close();
}
}
main().catch(console.error);
Collection löschen
Wir können diedrop()-Methode zum Löschen einer Sammlung verwenden:
drop()
var MongoClient = require('mongodb').MongoClient;
var url = "mongodb://localhost:27017/";
MongoClient.connect(url, function(err, db) {
if (err) throw err;
var dbo = db.db("example");
//Test-Collection löschen
dbo.collection("test").drop(function(err, delOK) { //Bei Erfolg gibt delOK true zurück; andernfalls gibt es false zurück.
if (err) throw err;
if (delOK) console.log("Collection gelöscht");
db.close();
});
});
Promise verwenden
Promise ist eine von ECMAScript 6 bereitgestellte Klasse, mit der komplexe asynchrone Aufgaben eleganter geschrieben werden können.
Wenn du Promise noch nicht verstehst, kannst du aufJavaScript Promise verweisen。
Das folgende Beispiel verwendet Promise, um eine Collection zu erstellen:
Beispiel
const { MongoClient } = require('mongodb');
//MongoDB-Verbindungs-URI
const uri = "mongodb://localhost:27017"; //Bitte passe es an deine MongoDB-Serveradresse an
//Neuen MongoClient erstellen
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
//Verwende Promise, um den Vorgang des Verbindens mit der Datenbank zu umschließen
function connectDB() {
return new Promise((resolve, reject) => {
//Verbindung zum MongoDB-Server herstellen
client.connect((err) => {
if (err) {
reject(err);
} else {
console.log("Erfolgreich mit dem MongoDB-Server verbunden");
resolve(client.db()); //Gibt die Datenbankinstanz zurück
}
});
});
}
//Anwendungsbeispiel
connectDB()
.then(database => {
//Hier kannst du weiterhin Datenbankoperationen ausführen
console.log("Erfolgreich mit der Datenbank verbunden");
//Beispiel: Den Namen der Datenbank ausgeben
console.log("Datenbankname:", database.databaseName);
//Wenn du weitere Operationen durchführen möchtest, kannst du hier weiter Code schreiben
//Zum Beispiel Abfragen, Einfügen von Dokumenten usw.
//Zum Schluss die Verbindung schließen
client.close();
})
.catch(err => {
console.error("Beim Verbinden mit der Datenbank ist ein Fehler aufgetreten:", err);
});
Promise-Datenoperationen
Jetzt implementieren wir vier aufeinanderfolgende Operationen in einem Programm: Hinzufügen, Abfragen, Aktualisieren und Löschen.
Beispiel
const { MongoClient, ObjectId } = require('mongodb');
//MongoDB-Verbindungs-URI
const uri = "mongodb://localhost:27017"; //Bitte passe es an deine MongoDB-Serveradresse an
//Neuen MongoClient erstellen
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
//Verwende Promise, um den Vorgang des Verbindens mit der Datenbank zu umschließen
function connectDB() {
return new Promise((resolve, reject) => {
//Verbindung zum MongoDB-Server herstellen
client.connect((err) => {
if (err) {
reject(err);
} else {
console.log("Erfolgreich mit dem MongoDB-Server verbunden");
resolve(client.db()); //Gibt die Datenbankinstanz zurück
}
});
});
}
//Funktion zum Hinzufügen eines Dokuments
function insertDocument(db, document) {
const collection = db.collection('documents');
return new Promise((resolve, reject) => {
collection.insertOne(document, (err, result) => {
if (err) {
reject(err);
} else {
console.log("Dokument erfolgreich hinzugefügt");
resolve(result);
}
});
});
}
//Funktion zum Abfragen von Dokumenten
function findDocuments(db) {
const collection = db.collection('documents');
return new Promise((resolve, reject) => {
collection.find({}).toArray((err, docs) => {
if (err) {
reject(err);
} else {
console.log("Ergebnis der Dokumentabfrage:");
console.log(docs);
resolve(docs);
}
});
});
}
//Funktion zum Aktualisieren eines Dokuments
function updateDocument(db, id, updatedValues) {
const collection = db.collection('documents');
return new Promise((resolve, reject) => {
collection.updateOne({ _id: ObjectId(id) }, { $set: updatedValues }, (err, result) => {
if (err) {
reject(err);
} else {
console.log("Dokument erfolgreich aktualisiert");
resolve(result);
}
});
});
}
//Funktion zum Löschen eines Dokuments
function deleteDocument(db, id) {
const collection = db.collection('documents');
return new Promise((resolve, reject) => {
collection.deleteOne({ _id: ObjectId(id) }, (err, result) => {
if (err) {
reject(err);
} else {
console.log("Dokument erfolgreich gelöscht");
resolve(result);
}
});
});
}
//Anwendungsbeispiel: Operationen zum Hinzufügen, Abfragen, Aktualisieren und Löschen nacheinander ausführen
async function performOperations() {
try {
const database = await connectDB();
//Dokument hinzufügen
const insertResult = await insertDocument(database, { name: "Dokument 1" });
//Dokumente abfragen
const findResult = await findDocuments(database);
//Dokument aktualisieren
const updatedDocId = insertResult.insertedId; //Verwende die beim Einfügen des Dokuments zurückgegebene ID zum Aktualisieren
const updateResult = await updateDocument(database, updatedDocId, { name: "Aktualisiertes Dokument 1" });
//Dokument löschen
const deleteResult = await deleteDocument(database, updatedDocId);
//Operationsergebnisse ausgeben
console.log("Letzte Operation abgeschlossen:");
console.log("Ergebnis des Löschens des Dokuments:", deleteResult);
} catch (err) {
console.error("Ein Fehler ist aufgetreten, während die Operation ausgeführt wurde:", err);
} finally {
//Achten Sie darauf, die Verbindung nach Abschluss zu schließen
await client.close();
}
}
//Führen Sie die Operation aus
performOperations();
Ausführungsergebnis:
数据库已连接
[ { _id: 5f1664966833e531d83d3ac6, site: 'example.com' } ]
[ { _id: 5f1664966833e531d83d3ac6, site: 'example.com' } ]
[]
Weitere Erweiterungen