Konfigurera MongoDB-drivrutinen med npm-modulen
För att få MongoDB node.js-drivrutinen måste vi först få npm-modulen för Node.js på vårt system, som bör uppdateras. Vi har installerat npm med den senaste versionen globalt på systemet. Kommandot för installation av npm-modulen finns nedan:
npm installera -g npm@9.8.1Här är det uppenbart att npm-modulen har lagts till i datorn.
Nu måste vi integrera MongoDB med Node.js-drivrutinen, så följande kommando hjälper oss att få Mongodb-drivrutinen genom att använda kommandot npm. Beroendena sparas av npm i en fil som heter 'package.json' med alternativet -save. Vi kan dock installera MongoDB-drivrutinen och lägga till den i projektets beroenden utan alternativet –save för att uppnå samma resultat.
npm installera mongodb --save
MongoDB-drivrutinen är nu framgångsrikt installerad, som visas i följande bild.
Nästa steg är att skapa en unik katalog där MongoDB-programmet kan placeras. För att göra detta, skapa katalogen 'NewFolder' med kommandot mkdir. Kommandot för att skapa katalogen är som följer:
mkdir New Folder
Nu har vi specificerat sökvägen som visas nedan för att komma in i den specifika katalogen.
cd C:\Users\Hp\MyNodejs\NewFolderSåledes är vi nu i katalogen 'NewFolder' som skapades i föregående steg. För att gå vidare till nästa process uppmanar vi kommandot 'npm init -y' för att snabbt initiera ett nytt Node.js-projekt genom att generera en package.json-fil med standardvärden utan att behöva indata från användaren.
Grundfilen package.json med standardvärden har skapats som kommandoutdata nedan.
Exempel # 1: Etablera anslutningen med MongoDB Server genom att integrera Node.js
Alla de första stegen för att få MongoDB-drivrutinen inom Node.js har slutförts framgångsrikt i avsnittet ovan. Nu kan vi enkelt upprätta en anslutning med MongoDB-servern. För detta har vi skapat en fil i katalogen 'NewFolder' med namnet 'MongoDB.js'. Skriptet för att upprätta anslutningen ges nedan.
const { MongoClient } = behöva ( 'mongodb' );const url = 'mongodb:// 127.0.0.1:27017 ' ;
const klient = ny MongoClient(url);
const db_name = 'NewDatabase' ;
asynkron funktion main() {
await client.connect();
console.log( 'Ansluten framgångsrikt till MongoDB-server' );
const db = klient.db(db_namn);
const collection = db.collection( 'användare' );
lämna tillbaka 'Gjort.' ;
}
main()
.then(console.log)
.catch(console.error)
.finally(() => client.close());
Vi har lagt till klassen 'MongoClient' från MongoDB-paketet för att generera MongoDB-serveranslutningen. Sedan specificerade vi variablerna 'url' och 'db_name' där MongoDB-serverns URL är definierad, som i det här fallet är localhost, och angav namnet på MongoDB-databasen 'NewDatabase.'
Efter det satte vi in async-funktionen och kallade den main(). Inuti den funktionen main() har vi använt funktionen connect() för att upprätta anslutningen, och när anslutningen har upprättats kommer loggen() att skriva ut meddelandet.
Efter att ha ställt in anslutningen kommer vi åt samlingen 'användare'. Här kan vi utföra olika databasoperationer i huvudfunktionen. Därefter anropas huvudfunktionen genom att använda main().then(console.log).catch(console.error) för att hantera framgångs- och felfall. Slutligen stängde vi MongoDB-anslutningen med client.close() i .finally()-blocket.
Utdatan visade att anslutningen med MongoDB-servern hade upprättats framgångsrikt när vi körde filen med nodkommandot.
Exempel # 2: Infoga dokument i MongoDB-samlingen genom att använda Node.js
Vi har anslutit till MongoDB-servern i föregående avsnitt. När anslutningen upprättas kan vi infoga dokumenten i samlingen som anges i ovanstående program. Operationen att infoga dokumentet i samlingen 'användare' läggs till i samma fil, 'MongoDB.js'.
const { MongoClient } = behöva ( 'mongodb' );const url = 'mongodb:// 127.0.0.1:27017 ' ;
const klient = ny MongoClient(url);
const db_name = 'NewDatabase' ;
asynkron funktion main() {
await client.connect();
console.log( 'Ansluten framgångsrikt till MongoDB-server' );
const db = klient.db(db_namn);
const collection = db.collection( 'användare' );
const insertDocs =
await collection.insertMany([{ namn: 'Alex' , e-post: ' alex@example.com ' },
{ namn: 'Andy' , e-post: ' andy@example.com ' },
{ namn: 'Han själv' , e-post: ' sam@example.com ' }]);
console.log( 'Infogade dokument i samling =>' , insertDocs);
lämna tillbaka 'Gjort.' ;
}
main()
.then(console.log)
.catch(console.error)
.finally(() => client.close());
Här är allt manus detsamma som ovan; vi infogade precis operationen för insättning i asynkronfunktionen main(). Vi skapade variabeln 'insertDocs' och anropade sedan funktionen insertMany() med kommandot await. För funktionen insertMany() har vi specificerat tre dokument som innehåller 'namn' och 'e-post'-fält med olika värden i varje. Ett uttalande kommer att genereras när alla dokument har infogats korrekt.
Utdata som visas dokumenten infogas framgångsrikt i samlingen med tre unika ID:n.
Exempel # 3: Uppdatera dokumentet till samlingen med hjälp av Node.js
På samma sätt kan vi också tillämpa uppdateringsoperationen för MongoDB i Node.js genom att följa samma fil, 'MongoDB.js.' Åtgärden läggs till i filen för uppdateringsåtgärden. Tänk på programmet för denna operation.
const { MongoClient } = behöva ( 'mongodb' );const url = 'mongodb:// 127.0.0.1:27017 ' ;
const klient = ny MongoClient(url);
const db_name = 'NewDatabase' ;
asynkron funktion main() {
await client.connect();
console.log( 'Ansluten framgångsrikt till MongoDB-server' );
const db = klient.db(db_namn);
const collection = db.collection( 'användare' );
const updateDoc = await collection.updateOne({ namn: 'andy' },
{ $set: { email: ' andy12@example.com ' } });
console.log( 'Dokument uppdaterat i samlingen=>' , updateDoc);
lämna tillbaka 'Gjort.' ;
}
main()
.then(console.log)
.catch(console.error)
.finally(() => client.close());
Här har vi kallat variabeln 'updateDocs' där uppdateringsoperationen definieras med $set-operatorn. UpdateOne()-metodens definition säger att endast ett dokument behöver uppdateras. I updateOne()-metoden i MongoDB har vi försett namnfältet med värde som den första satsen, och sedan har vi gett $set-operatorn till den andra satsen, där 'e-post'-fältet ges för att uppdatera det nya e-postmeddelandet i enlighet därmed .
Utdata visas där dokumentet som ska uppdateras matchas och modifieras med hjälp av Node.js.
Exempel # 4: Ta bort dokument från MongoDB-samlingen med hjälp av Node.js
Därefter tillämpade vi borttagningsoperationen för MongoDB med Node.js. Operationen tillhandahålls i den liknande filen 'MongoDB.js.'
const { MongoClient } = behöva ( 'mongodb' );const url = 'mongodb:// 127.0.0.1:27017 ' ;
const klient = ny MongoClient(url);
const db_name = 'NewDatabase' ;
asynkron funktion main() {
await client.connect();
console.log( 'Ansluten framgångsrikt till MongoDB-server' );
const db = klient.db(db_namn);
const collection = db.collection( 'användare' );
const deleteDoc = await collection.deleteOne({ namn: 'Andy' });
console.log( 'Dokument raderat=>' , deleteDoc);
lämna tillbaka 'Gjort.' ;
}
main()
.then(console.log)
.catch(console.error)
.finally(() => client.close());
Här har vi definierat den nya variabeln 'deleteDoc' där dokumentet raderas från samma samling 'användare'. Metoden deleteOne() tillhandahålls i variabeln 'deleteDoc' för att bara ta bort det specifika dokumentet, vilket är det med fältet 'namn' lagrat med värdet 'Andy'. När dokumentet raderas från samlingen genererar filen Node.js också raderingsmeddelandet.
Som förväntat har dokumentet raderats från MongoDB-samlingen 'användare'.
Slutsats
Vi visade hur man upprättar en anslutning till en MongoDB-databas och får åtkomst till en samling med MongoDB Node.js-drivrutinen. Efter framgångsrik anslutning till MongoDB har vi inkluderat ytterligare operationskod i huvudfunktionen för att utföra MongoDB-operationer.