Faire mongoose.js les requêtes s'exécutent de manière synchrone

Si vous utilisez node.js alors u doit utiliser https://github.com/caolan/async

lorsque vous devez récupérer des données à partir de plusieurs collections vous avez de la chaîne de vos requêtes à plusieurs reprises.

Il fera de votre code complexe et difficile à lire, et pas de la modularité. Utiliser asynchrone à créer
la modularité à l'aide de mongodb et node.js

Exemple de Code à partir de mon projet :

var async = require('async');

var createGlobalGroup = function(socket, data) {
    async.waterfall(
    [
    /**
     * this function is required to pass data recieved from client
     * @param  {Function} callback To pass data recieved from client
     */

    function(callback) {
        callback(null, socket, data);
    },
    /**
     * Step 1: Verify User
     */
    verifyUser,
    /**
     * Step 2: Check User Access Rights And Roles
     */
    checkUserAccessRightsAndRoles,
    /**
     * Step 3: Create Project
     */
    createNewGlobalGroup], function(err, result) {
        /**
         * function to be called when all functions in async array has been called
         */
        console.log('project created ....')
    });
}
verifyUser = function(socket, data, callback) {
//do your query
    /**
     * call next function in series
     * provide sufficient input to next function
     */
    callback(null, socket, data, {
        "isValidUser": true,
    });
}

checkUserAccessRightsAndRoles = function(socket, data, asyncObj, callback) {
    //do your query
    if(condition) {
        callback(null, socket, data, {
            roles: result,
            "isValidUser": asyncObj.isValidUser,
            "userId": asyncObj.userId,
        });
    } else {
    //no call back
    }
}

var createNewGlobalGroup = function(socket, data, asyncObj, callback) {
//wanna stop then no callback
}

OriginalL'auteur Harpreet Singh

Si vous utilisez le Nœud 8.x vous pouvez utiliser async/await: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/await

attendent opérateur suspend l'exécution de la fonction async jusqu'à ce que la Promesse est résolu et retourne la valeur. De cette façon, votre code est plus synchrone:

const query1 = MyModel.find({ name: /john/i }, null, { skip: 10 });
const result1 = await query1.exec();

const query2 = MyModel.find({ name: /john/i }, null, { skip: 100 });
const result2 = await query2.exec();

Requêtes seront exécutées successivement.

OriginalL'auteur vsenko

À synchroniser, j'ai utilisé es6-promesse.

var Promise = require('es6-promise').Promise
, mongoose = require('mongoose')
, Schema = mongoose.Schema;
//define schemas and models.
var placeSchema = new Schema({
name: { type: String },
memo: { type: String }
})
, Places = mongoose.model('place', placeSchema)
, visitSchema = new Schema({
placeName: { type: String }, //foreign key for place.
visitor: { type: String },
comment: { type: String }
})
, Visits = mongoose.model('visit', visitSchema);
//query for visits by visitor and place.
function findVisitsWithPlace(visitor, place) {
return new Promise(function (resolve, reject) {
Visits.find({
visitor: visitor,
placeName: place.name
}, function (error, visits) {
if (error) {
reject(error);
return;
}
//build a result object you want.
//()
resolve({
place: place,
visits: visits
});
});
});
}
//functions for node route.
module.exports = {
//- access to "GET /placevisits/?visitor=Visitor-1".
get: function (request, response) {
var visitor = request.query.visitor;
//- to get the places...
Places.find({}, function (error, places) {
Promise.all(places.map(function (place) {
//- run the child queries with parent object...
return findVisitsWithPlace(visitor, place);
})).then(function (placeAndVisits) {
//- and get result.
//placeAndVisits have still contain visits empty.
//exclude them.
var result = [];
placeAndVisits.forEach(function (placeandvisit) {
if (placeandvisit.visits.length != 0) {
result.push(placeandvisit);
}
});
response.json(result);
});
});
}
};

et j'ai eu JSON comme suit.

[
{
"place": {
"_id": "564e58a1dbed862155771d46",
"name": "Place-A",
"memo": "A memo for Place A."
},
"visits": [
{
"_id": "564e58cedbed862155771d49",
"placeName": "Place-A",
"visitor": "Visitor-1",
"comment": "A comment for Place A by Visitor-1"
},
{
"_id": "564e58dcdbed862155771d4a",
"placeName": "Place-A",
"visitor": "Visitor-1",
"comment": "2nd visit. Again comment for Place A by Visitor-1"
}
]
},
{
"place": {
"_id": "564e58afdbed862155771d47",
"name": "Place-B",
"memo": "A memo for Place B."
},
"visits": [
{
"_id": "564e58ebdbed862155771d4c",
"placeName": "Place-B",
"visitor": "Visitor-1",
"comment": "A comment for Place B by Visitor-1"
}
]
}
]

OriginalL'auteur Kohei Sugimura

Voici ce que j'ai fait ce soir.

mongoose.createConnection("mongodb://localhost:27017/chemresearch")
.then(async db => {
const collection = db.collection("chemical");
const all = collection.find({});
while(all.hasNext()) {
let chemical = await all.next();
await work(chemical);
}
});

La work méthode est tout juste de retour d'une promesse.

const work = (chemical) => new Promise((resolve, reject) => {
const casNumber = chemical.casRegistryNumber;
analysis(casNumber, (error) => {
error ? reject(error) : resolve(casNumber);
})
});

OriginalL'auteur Proximo