Node.js conectando a MongoDB
MongoDB es un sistema de gestión de bases de datos orientado a documentos, escrito en C++.
En este capítulo presentaremos cómo usar Node.js para conectarse a MongoDB y realizar operaciones en la base de datos.
Si aún no tienes conocimientos básicos de MongoDB, puedes consultar nuestro tutorial:Tutorial de MongoDB。
Instalar el driver
Este tutorial utilizael comando cnpm personalizado de Taobaopara instalar:
$ cnpm install mongodb
Una vez instalado correctamente, podemos usar el objeto MongoClient para conectarnos a la base de datos:
Ejemplo
const { MongoClient } = require('mongodb');
async function main() {
// URI de conexión a MongoDB
const uri = "mongodb://localhost:27017"; // Si estás usando MongoDB remoto, cambia la URI correspondientemente
// Crear un nuevo MongoClient
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
try {
// Conectar al servidor MongoDB
await client.connect();
console.log("Connected successfully to server");
} finally {
// Asegúrate de cerrar la conexión después de terminar
await client.close();
}
}
main().catch(console.error);
Ejecuta el código anterior, el resultado es:
Connected successfully to server
Explicación de los parámetros de conexión:
MongoClient: Este es el cliente de MongoDB, utilizado para conectarse a la base de datos.uri: Esta es la cadena de conexión de MongoDB, con el formatomongodb://[username:password@]host1[:port1][,...hostN[:portN]][/[defaultauthdb][?options]]。useNewUrlParseryuseUnifiedTopologyson algunas opciones, utilizadas para evitar comportamientos de conexión antiguos.
A continuación implementaremos las funciones de crear, leer, actualizar y eliminar.
Crear base de datos
Para crear una base de datos en MongoDB, primero necesitamos crear un objeto MongoClient y luego configurar la URL y el número de puerto especificados.
Si la base de datos no existe, MongoDB creará la base de datos y establecerá la conexión.
Crear conexión
const { MongoClient } = require('mongodb');
async function main() {
const uri = "mongodb://localhost:27017";
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
try {
await client.connect();
console.log("Conexión exitosa al servidor");
const database = client.db('ejemplo');
const collection = database.collection('exampleCollection');
const doc = { name: "Example", type: "Test" };
const result = await collection.insertOne(doc);
console.log(`Nuevo documento creado,IDcon _id: ${result.insertedId}`);
} finally {
await client.close();
}
}
main().catch(console.error);
Ejecuta el código anterior, el resultado es:
成功连接到服务器
新文档已创建,ID 为: 6678e18e0bb3f4247be610d8
Crear colección
Podemos usar el método createCollection() para crear una colección:
Crear colección
const { MongoClient } = require('mongodb');
async function main() {
const uri = "mongodb://localhost:27017";
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
try {
await client.connect();
console.log("Conexión exitosa al servidor");
const database = client.db('ejemplo');
const collectionName = 'exampleCollection';
await database.createCollection(collectionName);
console.log(`Colección ${collectionName}creada exitosamente`);
const collection = database.collection(collectionName);
const doc = { name: "Example", type: "Test" };
const result = await collection.insertOne(doc);
console.log(`Nuevo documento creado,IDcon _id: ${result.insertedId}`);
} finally {
await client.close();
}
}
main().catch(console.error);
Ejecuta el código anterior, el resultado es:
成功连接到服务器
集合 exampleCollection 创建成功
新文档已创建,ID 为: 6678e1b5c742b3ebd57f9759
Operaciones de base de datos (CRUD)
A diferencia de MySQL, MongoDB crea automáticamente la base de datos y las colecciones, por lo que no necesitamos crearlas manualmente antes de usarlas.
Insertar datos
En el siguiente ejemplo nos conectamos a la tabla exampleCollection de la base de datos ejemplo e insertamos un dato, usando insertOne():
Insertar un dato
const { MongoClient } = require('mongodb');
async function main() {
const uri = "mongodb://localhost:27017";
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
try {
await client.connect();
console.log("Conexión exitosa al servidor");
const database = client.db('ejemplo');
const collectionName = 'exampleCollection';
await database.createCollection(collectionName);
console.log(`Colección ${collectionName}creada exitosamente`);
const collection = database.collection(collectionName);
const doc = { name: "Alice", age: 25, address: "Wonderland" };
const result = await collection.insertOne(doc);
console.log(`Nuevo documento creado,IDcon _id: ${result.insertedId}`);
} finally {
await client.close();
}
}
main().catch(console.error);
Ejecuta el siguiente comando y el resultado es:
成功连接到服务器
集合 exampleCollection 创建成功
新文档已创建,ID 为: 6678e1d1f9503dc2e0e2a20b
Según el resultado de salida, los datos se han insertado correctamente.
También podemos abrir el cliente de MongoDB para ver los datos, por ejemplo:
> show dbs
ejemplo 0.000GB # 创建了 ejemplo 数据库
> use ejemplo # 切换到 ejemplo 数据库
ejemplo> show tables
exampleCollection # 创建了 exampleCollection 集合(数据表)
# 自动创建了 site 集合(数据表)
ejemplo> db.exampleCollection.find()
[
{
_id: ObjectId('6678e1d1f9503dc2e0e2a20b'),
name: 'Alice',
age: 25,
address: 'Wonderland'
}
]
Si quieres insertar múltiples datos, puedes usarinsertMany():
Insertar múltiples datos
const { MongoClient } = require('mongodb');
async function main() {
const uri = "mongodb://localhost:27017";
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
try {
await client.connect();
console.log("Conexión exitosa al servidor");
const database = client.db('ejemplo');
const collectionName = 'exampleCollection';
await database.createCollection(collectionName);
console.log(`Colección ${collectionName}creada exitosamente`);
const collection = database.collection(collectionName);
const docs = [
{ name: "Alice", age: 25, address: "Wonderland" },
{ name: "Bob", age: 30, address: "Builderland" },
{ name: "Charlie", age: 35, address: "Chocolate Factory" }
];
const result = await collection.insertMany(docs);
console.log(`${result.insertedCount}nuevos documentos creados,IDcon _id: `);
Object.keys(result.insertedIds).forEach((key, index) => {
console.log(`documento ${index + 1}: ${result.insertedIds[key]}`);
});
} finally {
await client.close();
}
}
main().catch(console.error);
Ejecuta y el resultado es:
成功连接到服务器
集合 exampleCollection 创建成功
3 个新文档已创建,ID 为:
文档 1: 6678e30e80ac30e5e689f13a
文档 2: 6678e30e80ac30e5e689f13b
文档 3: 6678e30e80ac30e5e689f13c
Consultar datos
Puedes usar find() para buscar datos; find() puede devolver todos los datos que coincidan con las condiciones. Si no se especifican condiciones, find() devuelve todos los datos de la colección.
find()
const { MongoClient } = require('mongodb');
async function main() {
const uri = "mongodb://localhost:27017";
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
try {
await client.connect();
console.log("Conexión exitosa al servidor");
const database = client.db('ejemplo');
const collectionName = 'exampleCollection';
await database.createCollection(collectionName);
console.log(`Colección ${collectionName}creada exitosamente`);
const collection = database.collection(collectionName);
const docs = [
{ name: "Alice", age: 25, address: "Wonderland" },
{ name: "Bob", age: 30, address: "Builderland" },
{ name: "Charlie", age: 35, address: "Chocolate Factory" }
];
const result = await collection.insertMany(docs);
console.log(`${result.insertedCount}nuevos documentos creados,IDcon _id: `);
Object.keys(result.insertedIds).forEach((id, index) => {
console.log(`documento ${index + 1}: ${id}`);
});
const query = {};
const options = { projection: { _id: 0, name: 1, age: 1, address: 1 } };
const cursor = collection.find(query, options);
const allValues = await cursor.toArray();
console.log("Documentos encontrados:");
console.log(allValues);
} finally {
await client.close();
}
}
main().catch(console.error);
Ejecuta y el resultado es:
成功连接到服务器
集合 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' }
]
El siguiente ejemplo recupera el documento con name "Alice":
Consultar datos con condiciones específicas
const { MongoClient } = require('mongodb');
async function main() {
const uri = "mongodb://localhost:27017";
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
try {
await client.connect();
console.log("Conexión exitosa al servidor");
const database = client.db('ejemplo');
const collectionName = 'exampleCollection';
await database.createCollection(collectionName);
console.log(`Colección ${collectionName}creada exitosamente`);
const collection = database.collection(collectionName);
const docs = [
{ name: "Alice", age: 25, address: "Wonderland" },
{ name: "Bob", age: 30, address: "Builderland" },
{ name: "Charlie", age: 35, address: "Chocolate Factory" }
];
const result = await collection.insertMany(docs);
console.log(`${result.insertedCount}Nuevo documento creado,IDes: `);
Object.keys(result.insertedIds).forEach((id, index) => {
console.log(`Documento ${index + 1}: ${id}`);
});
const query = { name: "Alice" };
const options = { projection: { _id: 0, name: 1, age: 1, address: 1 } };
const cursor = collection.find(query, options);
const allValues = await cursor.toArray();
console.log("Documentos consultados:");
console.log(allValues);
} finally {
await client.close();
}
}
main().catch(console.error);
Al ejecutar el siguiente comando, el resultado es:
成功连接到服务器
集合 exampleCollection 创建成功
3 个新文档已创建,ID 为:
文档 1: 0
文档 2: 1
文档 3: 2
查询到的文档:
[
{ name: 'Alice', age: 25, address: 'Wonderland' }
]
Actualizar datos
También podemos modificar los datos de la base de datos. El siguiente ejemplo actualiza los datos donde name es "Alice":
Actualizar un dato
const { MongoClient } = require('mongodb');
async function main() {
const uri = "mongodb://localhost:27017";
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
try {
await client.connect();
console.log("Conexión exitosa al servidor");
const database = client.db('ejemplo');
const collectionName = 'exampleCollection';
await database.createCollection(collectionName);
console.log(`Colección ${collectionName}creada correctamente`);
const collection = database.collection(collectionName);
const docs = [
{ name: "Alice", age: 25, address: "Wonderland" },
{ name: "Bob", age: 30, address: "Builderland" },
{ name: "Charlie", age: 35, address: "Chocolate Factory" }
];
const result = await collection.insertMany(docs);
console.log(`${result.insertedCount}Nuevos documentos creados,IDes: `);
Object.keys(result.insertedIds).forEach((id, index) => {
console.log(`Documento ${index + 1}: ${id}`);
});
const filter = { name: "Alice" };
const updateDoc = {
$set: {
age: 28,
address: "New Wonderland"
},
};
const updateResult = await collection.updateOne(filter, updateDoc);
console.log(`${updateResult.matchedCount}documento(s) coinciden con el filtro`);
console.log(`${updateResult.modifiedCount}documento(s) actualizado(s)`);
const updatedDocument = await collection.findOne(filter);
console.log("Documentos actualizados:");
console.log(updatedDocument);
} finally {
await client.close();
}
}
main().catch(console.error);
Después de una ejecución exitosa, el resultado es el siguiente:
成功连接到服务器
集合 exampleCollection 创建成功
3 个新文档已创建,ID 为:
文档 1: 0
文档 2: 1
文档 3: 2
1 个文档匹配筛选条件
1 个文档已更新
更新后的文档:
{
_id: new ObjectId('6678e1d1f9503dc2e0e2a20b'),
name: 'Alice',
age: 28,
address: 'New Wonderland'
}
Si quieres actualizar todos los documentos que coinciden con la condición, puedes usarupdateMany():
Actualizar múltiples datos
const { MongoClient } = require('mongodb');
async function main() {
const uri = "mongodb://localhost:27017";
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
try {
await client.connect();
console.log("Conexión exitosa al servidor");
const database = client.db('ejemplo');
const collectionName = 'exampleCollection';
await database.createCollection(collectionName);
console.log(`Colección ${collectionName}creada correctamente`);
const collection = database.collection(collectionName);
const docs = [
{ name: "Alice", age: 25, address: "Wonderland" },
{ name: "Bob", age: 30, address: "Builderland" },
{ name: "Alice", age: 28, address: "Old Wonderland" }
];
const result = await collection.insertMany(docs);
console.log(`${result.insertedCount}Nuevos documentos creados,IDes: `);
Object.keys(result.insertedIds).forEach((id, index) => {
console.log(`Documento ${index + 1}: ${id}`);
});
const filter = { name: "Alice" };
const updateDoc = {
$set: {
address: "Updated Wonderland"
},
};
const updateResult = await collection.updateMany(filter, updateDoc);
console.log(`${updateResult.matchedCount}documento(s) coinciden con el filtro`);
console.log(`${updateResult.modifiedCount}documento(s) actualizado(s)`);
const updatedDocuments = await collection.find(filter).toArray();
console.log("Documentos actualizados:");
console.log(updatedDocuments);
} finally {
await client.close();
}
}
main().catch(console.error);
Eliminar datos
El siguiente ejemplo elimina los datos donde name es "Alice":
Eliminar un dato
const { MongoClient } = require('mongodb');
async function main() {
const uri = "mongodb://localhost:27017";
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
try {
await client.connect();
console.log("Conexión exitosa al servidor");
const database = client.db('ejemplo');
const collectionName = 'exampleCollection';
await database.createCollection(collectionName);
console.log(`Colección ${collectionName}creada correctamente`);
const collection = database.collection(collectionName);
const docs = [
{ name: "Alice", age: 25, address: "Wonderland" },
{ name: "Bob", age: 30, address: "Builderland" },
{ name: "Charlie", age: 35, address: "Chocolate Factory" }
];
const result = await collection.insertMany(docs);
console.log(`${result.insertedCount}Nuevos documentos creados,IDes: `);
Object.keys(result.insertedIds).forEach((id, index) => {
console.log(`Documento ${index + 1}: ${id}`);
});
const filter = { name: "Alice" };
const deleteResult = await collection.deleteOne(filter);
console.log(`${deleteResult.deletedCount}documento(s) eliminado(s)`);
const remainingDocuments = await collection.find({}).toArray();
console.log("Documentos restantes:");
console.log(remainingDocuments);
} finally {
await client.close();
}
}
main().catch(console.error);
Después de una ejecución exitosa, el resultado es:
成功连接到服务器
集合 exampleCollection 创建成功
3 个新文档已创建,ID 为:
文档 1: 0
文档 2: 1
文档 3: 2
1 个文档已删除
剩余的文档:
[
{
_id: new ObjectId('6678e18e0bb3f4247be610d8'),
name: 'Example',
type: 'Test'
},
...
Si quieres eliminar múltiples documentos, puedes usardeleteMany()método
El siguiente ejemplo elimina todos los datos donde type es "en":
Eliminar múltiples datos
const { MongoClient } = require('mongodb');
async function main() {
const uri = "mongodb://localhost:27017";
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
try {
await client.connect();
console.log("Conexión exitosa al servidor");
const database = client.db('ejemplo');
const collectionName = 'exampleCollection';
await database.createCollection(collectionName);
console.log(`Colección ${collectionName}creada correctamente`);
const collection = database.collection(collectionName);
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" }
];
const result = await collection.insertMany(docs);
console.log(`${result.insertedCount}Nuevos documentos creados,IDes: `);
Object.keys(result.insertedIds).forEach((id, index) => {
console.log(`Documento ${index + 1}: ${id}`);
});
const filter = { name: "Alice" };
const deleteResult = await collection.deleteMany(filter);
console.log(`${deleteResult.deletedCount}documento(s) eliminado(s)`);
const remainingDocuments = await collection.find({}).toArray();
console.log("Documentos restantes:");
console.log(remainingDocuments);
} finally {
await client.close();
}
}
main().catch(console.error);
Ordenar
Para ordenar, se utiliza el método sort(), que acepta un parámetro que indica si es ascendente (1) o descendente (-1).
Por ejemplo:
{ type: 1 } // 按 type 字段升序
{ type: -1 } // 按 type 字段降序
Ordenar por type en orden ascendente:
Ordenar
const { MongoClient } = require('mongodb');
async function main() {
const uri = "mongodb://localhost:27017";
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
try {
await client.connect();
console.log("Conexión exitosa al servidor");
const database = client.db('ejemplo');
const collectionName = 'exampleCollection';
await database.createCollection(collectionName);
console.log(`Colección ${collectionName}creada correctamente`);
const collection = database.collection(collectionName);
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" }
];
const result = await collection.insertMany(docs);
console.log(`${result.insertedCount}Nuevos documentos creados,IDes: `);
Object.keys(result.insertedIds).forEach((id, index) => {
console.log(`Documento ${index + 1}: ${id}`);
});
const sortedDocsAsc = await collection.find().sort({ age: 1 }).toArray();
console.log("Documentos ordenados por el campo age en orden ascendente:");
console.log(sortedDocsAsc);
const sortedDocsDesc = await collection.find().sort({ age: -1 }).toArray();
console.log("Documentos ordenados por el campo age en orden descendente:");
console.log(sortedDocsDesc);
} finally {
await client.close();
}
}
main().catch(console.error);
Paginación de consultas
Si quieres especificar el número de resultados a devolver, puedes usarlimit()método, que solo acepta un parámetro que especifica el número de resultados a devolver.
limit(): leer dos datos
const { MongoClient } = require('mongodb');
async function main() {
const uri = "mongodb://localhost:27017";
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
try {
await client.connect();
console.log("Conexión exitosa al servidor");
const database = client.db('ejemplo');
const collectionName = 'exampleCollection';
await database.createCollection(collectionName);
console.log(`Colección ${collectionName}creada correctamente`);
const collection = database.collection(collectionName);
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" }
];
const result = await collection.insertMany(docs);
console.log(`${result.insertedCount}Nuevos documentos creados,IDes: `);
Object.keys(result.insertedIds).forEach((id, index) => {
console.log(`Documento ${index + 1}: ${id}`);
});
const limitedDocs = await collection.find().limit(3).toArray();
console.log("Limitar los resultados de la consulta a 3 documentos:");
console.log(limitedDocs);
} finally {
await client.close();
}
}
main().catch(console.error);
Si quieres especificar el número de documentos a omitir, puedes usarskip()método.
El método skip() se utiliza para omitir un número específico de documentos y devolver los resultados de los documentos restantes.
skip(): omitir los primeros dos datos, leer dos datos
const { MongoClient } = require('mongodb');
async function main() {
const uri = "mongodb://localhost:27017";
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
try {
await client.connect();
console.log("Conexión exitosa al servidor");
const database = client.db('ejemplo');
const collectionName = 'exampleCollection';
await database.createCollection(collectionName);
console.log(`Colección ${collectionName}creada correctamente`);
const collection = database.collection(collectionName);
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" }
];
const result = await collection.insertMany(docs);
console.log(`${result.insertedCount}Nuevos documentos creados,IDes: `);
Object.keys(result.insertedIds).forEach((id, index) => {
console.log(`Documento ${index + 1}: ${id}`);
});
const skippedDocs = await collection.find().skip(2).toArray();
console.log("Resultados de la consulta después de omitir los dos primeros documentos:");
console.log(skippedDocs);
} finally {
await client.close();
}
}
main().catch(console.error);
Operación de conexión
mongoDB no es una base de datos relacional, pero podemos usar$lookuppara implementar left join.
$lookup es un operador de pipeline de agregación en MongoDB utilizado para realizar left outer join. Se puede usar para buscar documentos en otra colección que coincidan con las condiciones y combinarlos.
Por ejemplo, tenemos dos colecciones de datos:
Colección 1: orders
[
{ "_id": 1, "product_id": 101, "quantity": 2 },
{ "_id": 2, "product_id": 102, "quantity": 1 },
{ "_id": 3, "product_id": 103, "quantity": 4 }
]
Colección 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 }
]
Ahora queremos usar la operación $lookup para asociar el campo product_id de la colección orders con el campo _id de la colección products y obtener los detalles de los productos de cada pedido.
El siguiente es un ejemplo de agregación de MongoDB para implementar esta función:
Ejemplo
const { MongoClient } = require('mongodb');
async function main() {
const uri = "mongodb://localhost:27017";
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
try {
await client.connect();
console.log("Conexión exitosa al servidor");
const database = client.db('mydatabase');
const ordersCollection = database.collection('orders');
const productsCollection = database.collection('products');
const pipeline = [
{
$lookup: {
from: 'products',
localField: 'product_id',
foreignField: '_id',
as: 'productDetails'
}
}
];
const result = await ordersCollection.aggregate(pipeline).toArray();
console.log("Resultado de la consulta con left outer join:");
console.log(result);
} finally {
await client.close();
}
}
main().catch(console.error);
Eliminar colección
Podemos usardrop()el método para eliminar la colección:
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("ejemplo");
dbo.collection("test").drop(function(err, delOK) {
if (err) throw err;
if (delOK) console.log("Colección eliminada");
db.close();
});
});
Usar Promise
Promise es una clase proporcionada por ECMAScript 6, con el objetivo de escribir tareas asíncronas complejas de manera más elegante.
Si aún no entiendes Promise, puedes consultarJavaScript Promise。
El siguiente ejemplo usa Promise para crear una colección:
Ejemplo
const { MongoClient } = require('mongodb');
const uri = "mongodb://localhost:27017";
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
function connectDB() {
return new Promise((resolve, reject) => {
client.connect((err) => {
if (err) {
reject(err);
} else {
console.log("Conexión exitosa al servidor de MongoDB");
resolve(client.db());
}
});
});
}
connectDB()
.then(database => {
console.log("Conexión a la base de datos exitosa");
console.log("Nombre de la base de datos:", database.databaseName);
client.close();
})
.catch(err => {
console.error("Error al conectar a la base de datos:", err);
});
Operaciones de datos con Promise
Ahora implementamos cuatro operaciones consecutivas en un programa: agregar, consultar, actualizar y eliminar.
Ejemplo
const { MongoClient, ObjectId } = require('mongodb');
const uri = "mongodb://localhost:27017";
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
function connectDB() {
return new Promise((resolve, reject) => {
client.connect((err) => {
if (err) {
reject(err);
} else {
console.log("Conexión exitosa al servidor de MongoDB");
resolve(client.db());
}
});
});
}
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("Documento agregado exitosamente");
resolve(result);
}
});
});
}
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("Resultado de la consulta de documentos:");
console.log(docs);
resolve(docs);
}
});
});
}
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("Documento actualizado exitosamente");
resolve(result);
}
});
});
}
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("Documento eliminado exitosamente");
resolve(result);
}
});
});
}
async function performOperations() {
try {
const database = await connectDB();
const insertResult = await insertDocument(database, { name: "Document 1" });
const findResult = await findDocuments(database);
const updatedDocId = insertResult.insertedId;
const updateResult = await updateDocument(database, updatedDocId, { name: "Updated Document 1" });
const deleteResult = await deleteDocument(database, updatedDocId);
console.log("Operación final completada:");
console.log("Resultado de eliminar documento:", deleteResult);
} catch (err) {
console.error("Error al ejecutar la operación:", err);
} finally {
await client.close();
}
}
performOperations();
Resultado de la ejecución:
数据库已连接
[ { _id: 5f1664966833e531d83d3ac6, site: 'example.com' } ]
[ { _id: 5f1664966833e531d83d3ac6, site: 'example.com' } ]
[]
Otras extensiones