వెబ్ డెవలపర్‌ల కోసం మొంగోడిబిని ఉపయోగించడం యొక్క అత్యంత ముఖ్యమైన ప్రయోజనాల్లో ఒకటి జావాస్క్రిప్ట్‌తో దాని అద్భుతమైన ఏకీకరణ. మొంగోడిబి స్థానిక జావాస్క్రిప్ట్ డ్రైవర్‌ను అందిస్తుంది, ఇది డెవలపర్‌లు జావాస్క్రిప్ట్ కోడ్‌ని ఉపయోగించి నేరుగా డేటాబేస్‌తో ఇంటరాక్ట్ అయ్యేలా చేస్తుంది. ఇప్పుడు, మేము జావాస్క్రిప్ట్‌లో MongoDB అప్లికేషన్‌లను సృష్టించడం ప్రారంభించే ముందు మెషీన్‌లో MongoDB Node.js డ్రైవర్‌ను ఇన్‌స్టాల్ చేయడం అవసరం. దీని కోసం మనం కింది ఆదేశాన్ని ఉపయోగించాలి:
npm i mongodbమీ JavaScript కోడ్ నుండి MongoDBతో ఇంటరాక్ట్ అవ్వడానికి డ్రైవర్ మమ్మల్ని అనుమతిస్తుంది మరియు డేటాబేస్‌కి కనెక్ట్ చేయడం, డేటాను ఇన్సర్ట్ చేయడం, డేటాను ప్రశ్నించడం మరియు డేటాను అప్‌డేట్ చేయడం వంటి వివిధ కార్యకలాపాలను నిర్వహించడానికి అనుమతిస్తుంది.
ఉదాహరణ 1: JavaScriptతో MongoDB కనెక్షన్‌ని అభివృద్ధి చేయండి
మొంగోడిబి సర్వర్‌తో జావాస్క్రిప్ట్‌తో కనెక్షన్‌ని ఏర్పాటు చేయడం ద్వారా ప్రారంభించండి, ఇది గతంలో చర్చించినట్లుగా “npm” మాడ్యూల్‌ని ఉపయోగించి సాధించవచ్చు.
స్థిరంగా { మొంగో క్లయింట్ } = అవసరం ( 'mongodb' ) ;
స్థిరంగా url = 'mongodb:// 127.0.0.1:27017 ' ;
స్థిరంగా క్లయింట్ = కొత్త మొంగో క్లయింట్ ( url ) ;
స్థిరంగా dbపేరు = 'MyDB' ;
సమకాలీకరణ ఫంక్షన్ ప్రధాన ( ) {
క్లయింట్ కోసం వేచి ఉండండి. కనెక్ట్ చేయండి ( ) ;
కన్సోల్. లాగ్ ( 'సర్వర్‌కి విజయవంతంగా కనెక్ట్ చేయబడింది' ) ;
స్థిరంగా db = క్లయింట్. db ( dbపేరు ) ;
స్థిరంగా సేకరణ = db సేకరణ ( 'వ్యక్తులు' ) ;
తిరిగి 'పూర్తి.' ;
}
ప్రధాన ( )
. అప్పుడు ( కన్సోల్. లాగ్ )
. క్యాచ్ ( కన్సోల్. లోపం )
. చివరకు ( ( ) => క్లయింట్. దగ్గరగా ( ) ) ;
మేము ముందుగా మా “File.js” ఫైల్‌లోని “mongodb” మాడ్యూల్ నుండి అవసరమైన MongoClientని దిగుమతి చేస్తాము. మేము MongoDB సర్వర్ (url) కోసం కనెక్షన్ URLని నిర్వచించాము మరియు పేర్కొన్న URLని ఉపయోగించి కొత్త MongoClient ఉదాహరణను సృష్టిస్తాము.
ఆ తర్వాత, కనెక్షన్‌లో ఉపయోగించాల్సిన MongoDB డేటాబేస్ (dbName) పేరును మేము పేర్కొంటాము. తరువాత, అసమకాలిక మెయిన్() ఫంక్షన్ మొంగోడిబి సర్వర్‌లోని ప్రధాన కార్యకలాపాలను నిర్వహిస్తుంది. ఇక్కడ, వెయిట్ క్లయింట్.కనెక్ట్()ని ఉపయోగించి మేము MongoDB సర్వర్‌కి కనెక్ట్ చేస్తాము. ఇది అసమకాలిక ఆపరేషన్, కాబట్టి కనెక్షన్ విజయవంతంగా స్థాపించబడే వరకు ఫంక్షన్ పాజ్ అవుతుంది. కనెక్షన్ విజయవంతంగా చేసిన తర్వాత ప్రాంప్ట్‌లో కనిపించే సందేశాన్ని మేము వీక్షిస్తాము. మేము client.db(dbName)ని ఉపయోగించి “dbName”లో పేర్కొన్న పేరుతో డేటాబేస్‌కు సూచనను పొందుతాము.
అప్పుడు, మేము db.collection(‘వ్యక్తులు’)ని ఉపయోగించి “వ్యక్తులు” అనే సేకరణకు సూచనను పొందుతాము. ప్రధాన () ఫంక్షన్‌ను నిర్వచించిన తర్వాత, మేము ఆపరేషన్‌లను అమలు చేయడానికి ప్రధాన ()ని పిలుస్తాము. ప్రధాన() ఫంక్షన్ విజయవంతంగా పరిష్కరించబడితే, అది .then(console.log)ని ఉపయోగించి ఫలితాన్ని (ఈ సందర్భంలో, ఇది “పూర్తయింది” స్ట్రింగ్) ముద్రిస్తుంది. అమలు సమయంలో లోపం ఉన్నట్లయితే, అది లోపాన్ని క్యాచ్ చేసి .catch(console.error)ని ఉపయోగించి ప్రింట్ చేస్తుంది. చివరగా, ఇది .finally(() => client.close())ని ఉపయోగించి MongoDB క్లయింట్ కనెక్షన్ మూసివేయబడిందని నిర్ధారిస్తుంది.
అందువల్ల, జావాస్క్రిప్ట్ ఫైల్‌లో MongoDB కనెక్షన్ స్థాపించబడిన సందేశాన్ని ప్రాంప్ట్ చూపుతుంది:
ఉదాహరణ 2: JavaScriptతో MongoDB పత్రాన్ని చొప్పించండి
ఇప్పుడు MongoDB సర్వర్‌తో కనెక్షన్ ఏర్పాటు చేయబడింది, మేము JavaScriptతో MongoDB ప్రశ్నలను ఉపయోగించవచ్చు. ఇక్కడ, మేము ఒకే పత్రాన్ని చొప్పించడానికి ఇన్సర్ట్ ప్రశ్నను వర్తింపజేస్తాము.
స్థిరంగా { మొంగో క్లయింట్ } = అవసరం ( 'mongodb' ) ;స్థిరంగా url = 'mongodb:// 127.0.0.1:27017 ' ;
స్థిరంగా క్లయింట్ = కొత్త మొంగో క్లయింట్ ( url ) ;
స్థిరంగా db పేరు = 'MyDB' ;
సమకాలీకరణ ఫంక్షన్ ప్రధాన ( ) {
స్థిరంగా db = క్లయింట్. db ( db పేరు ) ;
స్థిరంగా సేకరణ = db సేకరణ ( 'వినియోగదారులు' ) ;
స్థిరంగా ఇన్సర్ట్ డాక్ =
సేకరణ కోసం వేచి ఉండండి. చొప్పించు ( { పేరు : 'ఆండ్రూ' , వయస్సు : 23 } ) ;
కన్సోల్. లాగ్ ( 'పత్రం చొప్పించబడింది =' , ఇన్సర్ట్ డాక్ ) ;
తిరిగి 'పూర్తి.' ;
}
ప్రధాన ( )
. అప్పుడు ( కన్సోల్. లాగ్ )
. క్యాచ్ ( కన్సోల్. లోపం )
. చివరకు ( ( ) => క్లయింట్. దగ్గరగా ( ) ) ;
మేము ప్రధాన() ఫంక్షన్‌ని డేటాబేస్ చొప్పించే ఆపరేషన్‌ను నిర్వహించే అసమకాలిక ఫంక్షన్‌గా నిర్వచించాము. దాని లోపల, మేము MongoClient ఉదాహరణ మరియు URLని ఉపయోగించి MongoDB సర్వర్‌కి కనెక్ట్ చేస్తాము. అప్పుడు, మేము client.db(dbName)ని ఉపయోగించి పేర్కొన్న డేటాబేస్ (MyDB)ని యాక్సెస్ చేస్తాము మరియు db.collection('యూజర్లు')ని ఉపయోగించి డేటాబేస్ నుండి 'యూజర్స్' సేకరణను పొందుతాము.
ఆ తర్వాత, మేము సేకరణ.insertOne()ని ఉపయోగించి 'యూజర్‌ల' సేకరణలో ఫీల్డ్‌ల పేరుతో 'ఆండ్రూ' మరియు వయస్సు 23గా ఉన్న పత్రాన్ని చొప్పిస్తాము. insertOne() పద్ధతి చొప్పించడం యొక్క ఫలితంతో పరిష్కరించబడే వాగ్దానాన్ని అందిస్తుంది. జోడించిన పత్రం console.logని ఉపయోగించి చూపబడుతుంది. చివరగా, మేము MongoDB క్లయింట్ కనెక్షన్‌ని మూసివేస్తాము.
కింది అవుట్‌పుట్‌లో చూపిన విధంగా MongoDB డేటాబేస్ సేకరణలో చొప్పించిన పత్రం విజయవంతంగా చొప్పించబడింది:
ఉదాహరణ 3: JavaScriptతో MongoDB పత్రాన్ని కనుగొనండి
అదేవిధంగా, మునుపటి ఉదాహరణలో సృష్టించబడిన సేకరణ నుండి పత్రాన్ని కనుగొనడానికి మేము జావాస్క్రిప్ట్‌తో MongoDB యొక్క “కనుగొను” ప్రశ్నను వర్తింపజేయవచ్చు.
స్థిరంగా { మొంగో క్లయింట్ } = అవసరం ( 'mongodb' ) ;స్థిరంగా url = 'mongodb:// 127.0.0.1:27017 ' ;
స్థిరంగా క్లయింట్ = కొత్త మొంగో క్లయింట్ ( url ) ;
స్థిరంగా db పేరు = 'MyDB' ;
సమకాలీకరణ ఫంక్షన్ ప్రధాన ( ) {
స్థిరంగా db = క్లయింట్. db ( db పేరు ) ;
స్థిరంగా సేకరణ = db సేకరణ ( 'వినియోగదారులు' ) ;
స్థిరంగా ఫైండ్ క్వెరీ = { పేరు : 'ఆండ్రూ' } ;
స్థిరంగా findDoc = సేకరణ కోసం వేచి ఉండండి. కనుగొనండి ( ఫైండ్ క్వెరీ ) . శ్రేణికి ( ) ;
కన్సోల్. లాగ్ ( 'పత్రం =' , findDoc ) ;
}
ప్రధాన ( )
. అప్పుడు ( కన్సోల్. లాగ్ )
. క్యాచ్ ( కన్సోల్. లోపం )
. చివరకు ( ( ) => క్లయింట్. దగ్గరగా ( ) ) ;
మేము మొదట సృష్టించిన MongoClient ఉదాహరణ మరియు పేర్కొన్న URLని ఉపయోగించి MongoDB సర్వర్‌కు కనెక్ట్ చేసే ప్రధాన ఫంక్షన్ నుండి ప్రదర్శనతో ప్రారంభిస్తాము. అప్పుడు, మేము dbName అనేది గతంలో నిర్వచించిన డేటాబేస్ పేరు అయిన client.db(dbName)ని ఉపయోగించి MyDB డేటాబేస్‌ని యాక్సెస్ చేస్తాము.
తరువాత, మేము db.collection('users')ని ఉపయోగించి డేటాబేస్ నుండి 'వినియోగదారులు' సేకరణకు సూచనను పొందుతాము. 'findQuery' పేరుతో ఒక ప్రశ్న ఆబ్జెక్ట్ సృష్టించబడింది, ఇది తిరిగి పొందవలసిన పత్రాలు 'ఆండ్రూ'కి సమానమైన పేరు ఫీల్డ్‌ను కలిగి ఉండాలని నిర్దేశిస్తుంది. ఆ తర్వాత, మేము సేకరణ.find(findQuery)ని ఉపయోగించి 'వినియోగదారుల' సేకరణపై 'కనుగొను' ప్రశ్నను నిర్వహిస్తాము, అది సరిపోలిన పత్రాలకు కర్సర్‌ను అందిస్తుంది.
కొనసాగే ముందు ఫలితం పరిష్కరించబడిందని నిర్ధారించుకోవడానికి సేకరణ.find()కి ముందు “వెయిట్” కీవర్డ్ ఉపయోగించబడుతుంది. ఫైండ్ ఆపరేషన్ యొక్క ఫలితం toArray()ని ఉపయోగించి పత్రాల శ్రేణికి మార్చబడుతుంది మరియు కనుగొనబడిన పత్రాలు “findDoc” వేరియబుల్‌లో నిల్వ చేయబడతాయి. ఆ తర్వాత పత్రాలు console.logని ఉపయోగించి కన్సోల్‌కి లాగ్ చేయబడతాయి.
ఫలితంగా, MongoDB సేకరణ యొక్క కనుగొనబడిన పత్రం అమలులో ప్రదర్శించబడుతుంది:
ఉదాహరణ 4: JavaScriptతో MongoDB పత్రాన్ని నవీకరించండి
తరువాత, MongoDB సేకరణ యొక్క పేర్కొన్న పత్రాన్ని నవీకరించడానికి మేము జావాస్క్రిప్ట్‌లో “నవీకరణ” ఆపరేషన్ చేస్తాము.
స్థిరంగా { మొంగో క్లయింట్ } = అవసరం ( 'mongodb' ) ;స్థిరంగా url = 'mongodb:// 127.0.0.1:27017 ' ;
స్థిరంగా క్లయింట్ = కొత్త మొంగో క్లయింట్ ( url ) ;
స్థిరంగా db పేరు = 'MyDB' ;
సమకాలీకరణ ఫంక్షన్ ప్రధాన ( ) {
స్థిరంగా db = క్లయింట్. db ( db పేరు ) ;
స్థిరంగా సేకరణ = db సేకరణ ( 'వినియోగదారులు' ) ;
స్థిరంగా updateQuery = { పేరు : 'ఆండ్రూ' } ;
స్థిరంగా నవీకరణ పేరు = { $ సెట్ : { పేరు : 'తాను' } } ;
స్థిరంగా నవీకరణ ఫలితం = సేకరణ కోసం వేచి ఉండండి. నవీకరణ ఒకటి ( updateQuery , నవీకరణ పేరు ) ;
కన్సోల్. లాగ్ ( 'నవీకరించబడిన పత్రం =' , నవీకరణ ఫలితం ) ;
తిరిగి 'పూర్తి' ;
}
ప్రధాన ( )
. అప్పుడు ( కన్సోల్. లాగ్ )
. క్యాచ్ ( కన్సోల్. లోపం )
. చివరకు ( ( ) => క్లయింట్. దగ్గరగా ( ) ) ;
“వినియోగదారులు” సేకరణలో పత్రాన్ని నవీకరించడానికి, మేము ప్రధాన() ఫంక్షన్‌ను అమలు చేస్తాము. 'ఆండ్రూ'కి సమానమైన నేమ్ ఫీల్డ్‌తో పత్రాన్ని కనుగొనడానికి {name: 'Andrew' }ని ఉపయోగించి మేము 'నవీకరణ' ప్రశ్నను సిద్ధం చేస్తాము. ఆ తర్వాత, మేము {$set: {name: ‘Sam’ } }ని ఉపయోగించి సరిపోలిన పత్రం యొక్క పేరు ఫీల్డ్‌ను “Sam”కి సెట్ చేస్తాము.
మేము సేకరణ.updateOne(updateQuery, updateName)ని ఉపయోగించి నవీకరణను నిర్వహించడానికి “అప్‌డేట్” ప్రశ్న మరియు “నవీకరణ” ఆపరేషన్‌ని నిర్వచించాము. updateOne() పద్ధతి 'అప్‌డేట్' ప్రశ్నకు సరిపోలే మొదటి పత్రాన్ని అప్‌డేట్ చేస్తుంది మరియు అప్‌డేట్ ఫలితాన్ని సూచించే ఆబ్జెక్ట్‌ను అందిస్తుంది. “updateResult” వేరియబుల్ నవీకరణ చర్య యొక్క ఫలితాన్ని కలిగి ఉంటుంది.
తదుపరి అవుట్‌పుట్ స్క్రీన్ నవీకరించబడిన ప్రశ్న ఫలితాలను ప్రదర్శిస్తుంది:
ఉదాహరణ 5: JavaScriptతో MongoDB పత్రాన్ని తొలగించండి
చివరగా, మేము జావాస్క్రిప్ట్‌లోని మొంగోడిబి నుండి మునుపటి పత్రాన్ని తొలగించడానికి మొంగోడిబి యొక్క తొలగింపు పద్ధతిని ఉపయోగిస్తాము.
స్థిరంగా { మొంగో క్లయింట్ } = అవసరం ( 'mongodb' ) ;స్థిరంగా url = 'mongodb:// 127.0.0.1:27017 ' ;
స్థిరంగా క్లయింట్ = కొత్త మొంగో క్లయింట్ ( url ) ;
స్థిరంగా db పేరు = 'MyDB' ;
సమకాలీకరణ ఫంక్షన్ ప్రధాన ( ) {
స్థిరంగా db = క్లయింట్. db ( db పేరు ) ;
స్థిరంగా సేకరణ = db సేకరణ ( 'వినియోగదారులు' ) ;
స్థిరంగా deleteQuery = { పేరు : 'తాను' } ;
స్థిరంగా తొలగించు ఫలితం = సేకరణ కోసం వేచి ఉండండి. ఒకటి తొలగించు ( deleteQuery ) ;
కన్సోల్. లాగ్ ( 'తొలగించబడిన పత్రం =' , తొలగించు ఫలితం ) ;
తిరిగి 'పూర్తి' ;
}
ప్రధాన ( )
. అప్పుడు ( కన్సోల్. లాగ్ )
. క్యాచ్ ( కన్సోల్. లోపం )
. చివరకు ( ( ) => క్లయింట్. దగ్గరగా ( ) ) ;
మేము 'deleteQuery' పేరుతో 'తొలగించు' ప్రశ్న ఆబ్జెక్ట్‌ని సృష్టిస్తాము, ఇది తొలగించాల్సిన పత్రాల ప్రమాణాలను నిర్దేశిస్తుంది. ఈ సందర్భంలో, పేరు ఫీల్డ్ 'సామ్'కి సమానంగా ఉన్న పత్రాల కోసం శోధిస్తుంది. తొలగింపు ప్రశ్నను సిద్ధం చేసిన తర్వాత, మేము సేకరణ వస్తువు యొక్క deleteOne() పద్ధతిని ఉపయోగించి అసలు తొలగింపు చర్యను వర్తింపజేస్తాము.
మేము 'deleteQuery'ని 'deleteOne'కి ఆర్గ్యుమెంట్‌గా పాస్ చేస్తాము, ఇది ప్రశ్నలో పేర్కొన్న ప్రమాణాలకు అనుగుణంగా ఉండే మొదటి సరిపోలే పత్రాన్ని తొలగిస్తుంది. 'deleteResult' వేరియబుల్ తొలగింపు చర్య యొక్క ఫలితాన్ని కలిగి ఉంటుంది.
'javascript' ఫైల్‌ని ఉపయోగించి MongoDB సేకరణ నుండి పేర్కొన్న పత్రం తొలగించబడుతుంది:
ముగింపు
MongoDB Node.js డ్రైవర్ ద్వారా JavaScriptతో MongoDBని ఎలా ఉపయోగించాలో ఇప్పుడు మాకు ప్రాథమిక అవగాహన ఉంది. మేము JavaScriptతో పత్రం యొక్క కనెక్షన్ నుండి తొలగించడం వరకు వివిధ మొంగో DB కార్యకలాపాలతో అన్నింటినీ ప్రదర్శించాము. ఇక్కడ నుండి, మేము మరింత సంక్లిష్టమైన అప్లికేషన్‌లను రూపొందించవచ్చు మరియు అవసరమైన విధంగా MongoDBని Node.js ప్రాజెక్ట్‌లలోకి చేర్చవచ్చు.