Node.js में वादों के साथ MongoDB का उपयोग कैसे करें?

Question 1

मैं Node.js के साथ MongoDB का उपयोग करने का तरीका खोजने की कोशिश कर रहा हूं और डॉक्स में यह सुझाव दिया गया है कि कमियां का उपयोग करना है। अब, मुझे पता है कि यह सिर्फ वरीयता का मामला है, लेकिन मैं वास्तव में वादों का उपयोग करना पसंद करता हूं।

समस्या यह है कि मैं उन्हें MongoDB के साथ उपयोग करने का तरीका नहीं मिला। वास्तव में, मैंने निम्नलिखित कोशिश की है:

var MongoClient = require('mongodb').MongoClient;

var url = 'mongodb://localhost:27017/example';

MongoClient.connect(url).then(function (err, db) {
    console.log(db);
});

और परिणाम है undefined। उस मामले में ऐसा लगता है कि यह ऐसा करने का तरीका नहीं है।

क्या कॉलबैक के बजाय वादों के साथ नोड के अंदर मोंगो डीबी का उपयोग करने का कोई तरीका है?

Question 2

आपका दृष्टिकोण लगभग सही है, आपके तर्क में बस एक छोटी सी गलती है

var MongoClient = require('mongodb').MongoClient
var url = 'mongodb://localhost:27017/example'
MongoClient.connect(url)
  .then(function (db) { // <- db as first argument
    console.log(db)
  })
  .catch(function (err) {})

Question 3

आप async / प्रतीक्षा भी कर सकते हैं

async function main(){
 let client, db;
 try{
    client = await MongoClient.connect(mongoUrl, {useNewUrlParser: true});
    db = client.db(dbName);
    let dCollection = db.collection('collectionName');
    let result = await dCollection.find();   
    // let result = await dCollection.countDocuments();
    // your other codes ....
    return result.toArray();
 }
 catch(err){ console.error(err); } // catch any mongo error here
 finally{ client.close(); } // make sure to close your connection after
}

स्निपेट का विस्तार करें

Question 4

चूंकि ऊपर दिए गए उत्तरों में से कोई भी नहीं है कि यह बिना ब्लूबर्ड या q या किसी अन्य फैंसी लाइब्रेरी के कैसे किया जाए, तो मुझे इस पर अपने 2 सेंट जोड़ने चाहिए।

यहाँ आप मूल ES6 वादों के साथ एक प्रविष्टि कैसे करते हैं

    'use strict';

const
    constants = require('../core/constants'),
    mongoClient = require('mongodb').MongoClient;



function open(){

    // Connection URL. This is where your mongodb server is running.
    let url = constants.MONGODB_URI;
    return new Promise((resolve, reject)=>{
        // Use connect method to connect to the Server
        mongoClient.connect(url, (err, db) => {
            if (err) {
                reject(err);
            } else {
                resolve(db);
            }
        });
    });
}

function close(db){
    //Close connection
    if(db){
        db.close();
    }
}

let db = {
    open : open,
    close: close
}

module.exports = db;

मैंने अपनी खुली () पद्धति को एक वादे के रूप में परिभाषित किया। एक प्रविष्टि करने के लिए, यहाँ नीचे मेरा कोड स्निपेट है

function insert(object){
    let database = null;
    zenodb.open()
    .then((db)=>{
        database = db;
        return db.collection('users')    
    })
    .then((users)=>{
        return users.insert(object)
    })
    .then((result)=>{
        console.log(result);
        database.close();
    })
    .catch((err)=>{
        console.error(err)
    })
}



insert({name: 'Gary Oblanka', age: 22});

उम्मीद है की वो मदद करदे। यदि आपके पास इसे बेहतर बनाने के लिए कोई सुझाव है, तो मुझे बताएं क्योंकि मैं खुद को बेहतर बनाने के लिए तैयार हूं :)

Question 5

यह एक सामान्य उत्तर है कि Node.js में वादों के साथ MongoDB का उपयोग कैसे करें?

यदि कॉलबैक पैरामीटर को छोड़ दिया जाता है तो मोंगोडब एक वादा लौटाएगा

वादा करने से पहले

var MongoClient = require('mongodb').MongoClient,
dbUrl = 'mongodb://db1.example.net:27017';

MongoClient.connect(dbUrl,function (err, db) {
    if (err) throw err
    else{
        db.collection("users").findOne({},function(err, data) {
            console.log(data)
        });
    }
})

प्रॉमिस में बदलने के बाद

//converted
MongoClient.connect(dbUrl).then(function (db) {
    //converted
    db.collection("users").findOne({}).then(function(data) {
         console.log(data)
    }).catch(function (err) {//failure callback
         console.log(err)
    });
}).catch(function (err) {})

आप कई अनुरोध को संभालने की जरूरत है

MongoClient.connect(dbUrl).then(function (db) {

   /*---------------------------------------------------------------*/

    var allDbRequest = [];
    allDbRequest.push(db.collection("users").findOne({}));
    allDbRequest.push(db.collection("location").findOne({}));
    Promise.all(allDbRequest).then(function (results) {
        console.log(results);//result will be array which contains each promise response
    }).catch(function (err) {
         console.log(err)//failure callback(if any one request got rejected)
    });

   /*---------------------------------------------------------------*/

}).catch(function (err) {})

Question 6

चेतावनी संपादित करें:

जैसा कि जॉन कल्विनर ने उल्लेख किया है, यह उत्तर पदावनत है। चालक का उपयोग करें, यह ओओटीबी के वादों के साथ आता है।

यदि आप एक वादा पुस्तकालय के रूप में ब्लूबर्ड का उपयोग करना चुनते हैं, तो आप promisifyAll()MongoClient पर ब्लूबर्ड्स फ़ंक्शन का उपयोग कर सकते हैं :

var Promise = require('bluebird');
var MongoClient = Promise.promisifyAll(require('mongodb').MongoClient);

var url = 'mongodb://localhost:27017/example';

MongoClient.connectAsync(url).then(function (db) {
    console.log(db);
}).catch(function(err){
    //handle error
    console.log(err);
});

Question 7

मुझे पता है कि मैं पार्टी के लिए थोड़ा लेट हूं लेकिन मैं ES6 का उपयोग करके एक उदाहरण साझा करना चाहता हूं

const config = require('config');
const MongoClient = require('mongodb').MongoClient;

var _connection;
var _db;

const closeConnection = () => {
  _connection.close();
}

/**
 * Connects to mongodb using config/config.js
 * @returns Promise<Db> mongo Db instance
 */
const getDbConnection = async () => {
  if (_db) {
    return _db;
  }
  console.log('trying to connect');
  const mongoClient = new MongoClient(config.mongodb.url, { useNewUrlParser: true });
  _connection = await mongoClient.connect();
  _db = _connection.db(config.mongodb.databaseName);
  return _db;
}

module.exports = { getDbConnection, closeConnection };

यदि आप एक बार देखना चाहते हैं तो मैं यहाँ और अधिक विस्तार में जा रहा हूँ:

https://medium.com/swlh/how-to-connect-to-mongodb-using-a-promise-on-node-js-59dd6c4d44a7

Question 8

आप या तो वैकल्पिक पैकेज का उपयोग कर सकते हैं, जैसे mongodb-promiseकि mongodbपैकेज एपीआई को मैन्युअल रूप से या उसके चारों ओर अपने स्वयं के वादों के निर्माण के द्वारा या वादा उपयोगिता के माध्यम से सेट करें।bluebird.promisify

Question 9

MongoDB संस्करण> 3.0 के साथ कार्य समाधान

var MongoClient = require('mongodb').MongoClient;
var url = "mongodb://localhost:27017/";


open = (url) => {
    return new Promise((resolve,reject) => {
        MongoClient.connect(url, (err,client) => { //Use "client" insted of "db" in the new MongoDB version
            if (err) {
                reject(err)
            } else {
                resolve({
                    client
                });
            };
        });
    });
};

create = (client) => {
    return new Promise((resolve,reject) => {
        db = client.db("myFirstCollection"); //Get the "db" variable from "client"
        db.collection("myFirstCollection").insertOne({
            name: 'firstObjectName',
            location: 'London'
            }, (err,result)=> {
                if(err){reject(err)}
                else {
                    resolve({
                        id: result.ops[0]._id, //Add more variables if you want
                        client
                    });
                }

            });
    });
};

close = (client) => {
    return new Promise((resolve,reject) => {
        resolve(client.close());
    })

};

open(url)
    .then((c) => {
        clientvar = c.client;
        return create(clientvar)
    }).then((i) => {
        idvar= i.id;
        console.log('New Object ID:',idvar) // Print the ID of the newly created object
        cvar = i.client
        return close(cvar)
    }).catch((err) => {
        console.log(err)
    })

Question 10

आपको एक वादा बनाने की ज़रूरत है जो मोंगो से जोड़ता है।

फिर, अपने फ़ंक्शन को परिभाषित करें जो इस वादे का उपयोग करता है myPromise.then(...):।

उदाहरण के लिए:

function getFromMongo(cb) {
    connectingDb.then(function(db) {

       db.collection(coll).find().toArray(function (err,result){
           cb(result);
       });

    });
}

यहाँ पूर्ण कोड है:

http://jsfiddle.net/t5hdjejg/

Question 11

कनेक्शन खोलने के लिए यहां एक लाइनर है

export const openConnection = async ()  =>
     await MongoClient.connect('mongodb://localhost:27017/staticback')

और इसे इस तरह से कॉल करें

const login = async () => 
const client = await openConnection()

Question 12

ऐसा नहीं लगता है कि कनेक्ट विधि में एक वादा इंटरफ़ेस परिभाषित है

http://mongodb.github.io/node-mongodb-native/2.1/tutorials/connect/

आप हमेशा इसे मोंगोडब कनेक्टर लाइब्रेरी में खुद को लागू कर सकते हैं, लेकिन यह संभवतः आप की तुलना में अधिक शामिल है।

यदि आपको वास्तव में वादों के साथ काम करने की आवश्यकता है, तो आप हमेशा ES6 वादे पॉलीफ़िल का उपयोग कर सकते हैं:

https://github.com/stefanpenner/es6-promise

और उस के साथ अपना कनेक्शन कोड लपेटें। कुछ इस तरह

var MongoClient = require('mongodb').MongoClient;
var Promise = require('es6-promise').Promise;

var url = 'mongodb://localhost:27017/example';

var promise = new Promise(function(resolve, reject){
    MongoClient.connect(url, function (err, db) {
        if(err) reject(err);
        resolve(db);
    });        
});

promise.then(<resolution code>);