Quelle est la bonne façon de faire un synchrones MongoDB requête en Node.js?

Je suis en utilisant le Node.JS pilote pour MongoDB, et j'aimerais effectuer une requête synchrone, comme tel:

function getAThing()
{
    var db = new mongo.Db("mydatabase", server, {});

    db.open(function(err, db)
    {
        db.authenticate("myuser", "mypassword", function(err, success)
        {
            if (success)
            {
                db.collection("Things", function(err, collection)
                {
                    collection.findOne({ name : "bob"}, function(err, thing)
                    {                           
                        return thing;
                    });
                });
            }
        });
    });
}

Le problème est, db.open est une asychronous appel (il n'a pas de bloc), de sorte que le getAThing retourne "undefined" et je veux qu'il renvoie les résultats de la requête. Je suis sûr que j'aurais une sorte de mécanisme de blocage, mais je voudrais connaître la bonne façon de faire quelque chose comme cela.

InformationsquelleAutor Mike Pateras | 2012-08-19
  1. 19

    Il n'y a aucun moyen de faire ce synchrone w/o une sorte de terrible hack. La bonne façon est d'avoir getAThing accepter une fonction de rappel en tant que paramètre et ensuite appeler cette fonction à la fois thing est disponible.

    function getAThing(callback)
{
    var db = new mongo.Db("mydatabase", server, {});

    db.open(function(err, db)
    {
        db.authenticate("myuser", "mypassword", function(err, success)
        {
            if (success)
            {
                db.collection("Things", function(err, collection)
                {
                    collection.findOne({ name : "bob"}, function(err, thing)
                    {       
                        db.close();                    
                        callback(err, thing);
                    });
                });
            }
        });
    });
}

    Nœud De 7,6+ Mise À Jour

    async/attendre maintenant fournit un moyen de codage synchrone style lors de l'utilisation des Api asynchrones que le retour des promesses (comme le natif de MongoDB pilote n').

    À l'aide de cette approche, la méthode ci-dessus peut être écrite comme:

    async function getAThing() {
    let db = await mongodb.MongoClient.connect('mongodb://server/mydatabase');
    if (await db.authenticate("myuser", "mypassword")) {
        let thing = await db.collection("Things").findOne({ name: "bob" });
        await db.close();
        return thing;
    }
}

    Que vous pouvez ensuite appeler à partir d'un autre async fonction let thing = await getAThing();.

    Cependant, il est intéressant de noter que MongoClient fournit un pool de connexion, de sorte que vous ne devriez pas être d'ouverture et de fermeture à l'intérieur de cette méthode. Au lieu de cela, appelez MongoClient.connect au cours de votre application de démarrage, puis simplifier votre méthode:

    async function getAThing() {
    return db.collection("Things").findOne({ name: "bob" });
}

    Noter que nous ne les appelons pas await dans la méthode, au lieu de retourner directement à la promesse qui est renvoyé par le findOne.

    • Merci Johnny pour cette solution de contournement! Je souhaite qu'il y avait un moyen simple de sortir de la boîte... c'est frustrant, même pour écrire une simple if_exists() fonction... Btw, si quelqu'un connaît un moyen plus facile, ou une mise à jour du pilote, veuillez le poster ici.
    • Vous pouvez toujours utiliser un async bibliothèque, afin d'éviter l'identation de "doom" github.com/caolan/async Qui va rendre le code plus lisible et agréable.
    • Je n'appellerais pas ça une "solution de contournement", c'est la façon dont le nœud est conçu pour fonctionner.
    • si c'est la bonne façon de le faire ... 🙁
    • retourné thing est un '[objet de la Promesse]'. Comment pouvons-nous lire les données à l'intérieur de la promesse de l'objet? (sans .then de rappel)
    • Vous pouvez await la promesse de l'intérieur d'une autre async fonction: let thing = await getAThing();
    • Je suis en train de déménager de la fonction de rappel d'un modèle où il est facile de gérer une erreur ou de réussite résultat, c'est à dire function(err, result) { if (err) { res.send(err) } else { // do things } - comment gérez-vous/voir une erreur qui provient let thing = await db.collection.findOne(query)?
    • Avec await vous devez utiliser les blocs try/catch pour le traitement des erreurs.
    • de cette façon? try { var bob = await getAThing() } catch(err) { console.log("mongodb query error is here: " + err ) }
    • Oui. Voir here pour plus d'exemples.

    InformationsquelleAutor JohnnyHK
  2. 31

    ES 6 (Nœud 8+)

    Vous pouvez utiliser async/await

    await opérateur interrompt l'exécution de fonctions asynchrones jusqu'à ce que la Promesse est résolu et renvoie la valeur.

    De cette façon, votre code fonctionne de façon synchrone:

    const query = MySchema.findOne({ name: /tester/gi });
const userData = await query.exec();
console.log(userData)

    Les Plus Âgés De La Solution - Juin 2013 😉

    Maintenant la Mongo Sync est disponible, c'est la bonne façon de faire un synchrones MongoDB requête en Node.js.

    Je me sers de ce pour la même chose. Il vous suffit d'écrire la méthode sync comme ci-dessous:

    var Server = require("mongo-sync").Server;
var server = new Server('127.0.0.1');
var result = server.db("testdb").getCollection("testCollection").find().toArray();
console.log(result);

    Note: Sa dépend de la nœud en fibre de et certaines questions sont là avec sur windows 8.

    Heureux de codage 🙂

    • J'ai codé un 5 ligne de script avec mongo-sync et il a échoué, même si elle correspondait à leur code de test presque parfaitement. Il semble avoir de bugs.
    • Pouvez-vous décrire le problème précis que vous aviez? parce que son travail pour moi pas de problèmes majeurs.. Si vous êtes sûr que c'est un bug dans le module, vous pouvez soulever une nouvelle question sur Repo
    • J'ai soumis un bug. Apparemment, vous devez supprimer les modules de fibres de node_modules dans le mongo-sync lib. Ressemble à un problème d'emballage.
    • Si c'est dépendante sur le nœud de fibres de puis ce n'est pas synchrone
    InformationsquelleAutor Amol M Kulkarni
  3. 2

    Alors qu'il n'est pas strictement synchrone, un modèle que j'ai à plusieurs reprises adopté et a trouvé très utile est d'utiliser co et promisify rendement asynchrone fonctions. Pour mongo, vous pouvez réécrire la ci-dessus:

    var query = co( function* () {

    var db = new mongo.Db("mydatabase", server, {});
    db = promisify.object( db );
    db = yield db.open();

    yield db.authenticate("myuser", "mypassword");

    var collection = yield db.collection("Things");
    return yield collection.findOne( { name : "bob"} );

});

query.then( result => {

} ).catch( err => {

} );

    Cela signifie:

    1. Vous pouvez écrire "synchrone"comme code avec n'importe quel asynchrone bibliothèque
    2. Erreurs sont jetés par les rappels, ce qui signifie que vous n'avez pas besoin de la réussite de vérifier
    3. Vous pouvez passer à la suite, comme une promesse à tout autre morceau de code
    InformationsquelleAutor Hugheth