Comment se déplacer sur ce problème asynchrone mongodb / nœud?

JavaScript est asynchrone. comptes.findone code> renvoie immédiatement, de sorte que toutes vos 4 déclarations sont exécutées ensemble.

what comptes.findone code> est, il dit que trouver un {" Email ": email} code> et lorsque vous le trouvez, exécutez la fonction qui se trouve dans le deuxième argument. Ensuite, il renvoie la fonction et continue à la prochaine déclaration CreeteAcount. En attendant, lorsque les résultats sont renvoyés à partir du disque dur (qui prend beaucoup plus de temps que l'exécution de ces déclarations), il entre dans la fonction, et comme il n'y a pas d'utilisateur, il en ajoute un. A du sens? P>

Mise à jour forte> C'est la bonne façon de le faire en JavaScript. P>

MongoClient.connect("mongodb://localhost:27017/bq", function(err, db) {
   if(err) { return console.dir(err); }

    db.createCollection('accounts', function(err, collection) {
        if(err) { return console.dir(err); }
        else { accounts = collection; }

        createAccount("bob","bob", function() {
            createAccount("bob","bob", function() {
                createAccount("bob","bob", function() {
                    createAccount("bob","bob", function() {
                     });
                });
            });
        });
    });
});


function createAccount(email, password, fn)
{
    accounts.findOne({"email":email}, function(err, item) {
        if(err) { console.dir(err); }
        else {
            if(item === null) {
                accounts.insert({"email":email, "password":password}, function(err, result) {
                    if(err) { console.dir(err); }
                    else { console.dir("Account " + email + " created."); }
                    fn();
                });
            }
            else {
                console.dir("Account already exists.")
                fn();
            }

        }
    });
}

Ajoutez une contrainte unique sur le courrier électronique et vous n'aurez plus à vérifier si l'utilisateur existe plus!

Certaines langues fournissent une construction de langue spéciale pour faire face à ce problème. Par exemple, c # a async / attendre des mots-clés qui vous permettent d'écrire le code comme si vous appeliez des API synchrones.

JavaScript ne doit pas et vous devez chaîner les appels CreeACECCount avec rappels.

Certaines personnes ont développé des bibliothèques pouvant vous aider à organiser ce code. Par exemple async , étape , promesses et q < / a>

Vous pouvez également utiliser le Fibres bibliothèque, une bibliothèque indigène qui étend le temps d'exécution JavaScript avec des fibres / des coroutines.

et certaines personnes ont étendu la langue avec des constructions similaires à async / attendre : Streamline.js , ICEDCOffeScript ou wind.js . Par exemple, streamline.js (je suis l'auteur, donc je suis évidemment biaisé) utilise _ comme un espace réservé de rappel spécial et vous permet d'écrire votre exemple comme: xxx < / pré>

et, enfin mais non le moindre, de nouvelles fonctionnalités linguistiques telles que générateurs et Les fonctions différées sont en cours de discussion pour les futures versions de JavaScript (les générateurs sont très susceptibles d'atterrir en ES6, Les fonctions différées semblent être un peu calquées).

Vous avez donc de nombreuses options:

• Stick to Callbacks
• Utilisez une bibliothèque d'assistance
• Utilisez l'extension d'exécution des fibres
• Utilisez une extension de langue
• Attendez ES6