Jak obejść problem asynchroniczny w MongoDB/Node?

Question

Mam następujący kod:

// Retrieve 
var MongoClient = require("mongodb").MongoClient; 
var accounts = null; 
var characters = null; 

// Connect to the db 
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"); 
     createAccount("bob","bob"); 
     createAccount("bob","bob"); 
     createAccount("bob","bob"); 
    }); 
}); 


function createAccount(email, password) 
{ 
    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."); } 
       }); 
      } 
      else { 
       console.dir("Account already exists.") 
      } 

     } 
    }); 
} 

Kiedy uruchomić skrypt po raz pierwszy, ja skończyć z 4 kont dla Boba. Kiedy uruchomię go po raz drugi, otrzymuję 4 wiadomości, że konto już istnieje.

Jestem pewien, że wiem, dlaczego tak jest, a rozwiązaniem, które wymyśliłem, jest użycie kolejki do przetwarzania każdego odczytu/zapisu bazy danych w kolejności pojedynczej. Chciałbym wiedzieć, czy jest to właściwy sposób, aby to osiągnąć i jaka byłaby najlepsza ogólna praktyka w tym zakresie?

Answer 1

Niektóre języki zapewniają specjalną konstrukcję językową do rozwiązania tego problemu. Na przykład słowa kluczowe C# mają async/await, które umożliwiają napisanie kodu tak, jakby wywoływano synchroniczne interfejsy API.

JavaScript nie jest i musisz połączyć się z połączeniami createAccount z oddzwonień.

Niektóre osoby opracowały biblioteki, które mogą pomóc w organizacji tego kodu. Na przykład async, step, node-promise i Q

Można również korzystać z biblioteki fibers, natywną bibliotekę, która rozciąga runtime JavaScript włóknami/współprogram.

A niektórzy ludzie rozszerzony język konstruktami, które są podobne do async/await: streamline.js, IcedCoffeeScript lub wind.js. Na przykład, streamline.js (jestem autorem, więc jestem oczywiście stronniczy) wykorzystuje _ jako specjalny zwrotnej zastępczy i pozwala pisać swój przykład jako:

var db = MongoClient.connect("mongodb://localhost:27017/bq", _): 
var accounts = db.createCollection('accounts', _); 
createAccount("bob","bob", _); 
createAccount("bob","bob", _); 
createAccount("bob","bob", _); 
createAccount("bob","bob", _); 

function createAccount(email, password, _) { 
    var item = accounts.findOne({"email":email}, _); 
    if (item === null) { 
     accounts.insert({"email":email, "password":password}, _); 
     console.log("Account " + email + " created."); } 
    } else { 
     console.log("Account already exists.") 
    } 
} 

I, last but not least, nowy język funkcje takie jak generators i deferred functions są omawiane dla przyszłych wersji JavaScript (generatory są bardzo prawdopodobne, aby wylądować w ES6, odroczone funkcje wydają się być nieco zablokowane).

więc masz wiele opcji:

• trzymać callbacków
• użyć biblioteki pomocnika
• używać rozszerzenia włókna wykonania
• używać rozszerzeniem języka
• czekać na ES6

Answer 2

JavaScript jest asynchroniczny. accounts.findOne powraca natychmiast, więc zasadniczo wszystkie twoje 4 polecenia są wykonywane razem.

To, co robi accounts.findOne, to znajdź jeden {"email":email}, a kiedy go znajdziesz, uruchom funkcję, która jest w drugim argumencie. Następnie zwraca funkcję i przechodzi do następnej instrukcji CreateAccount. W międzyczasie, gdy wyniki są zwracane z dysku twardego (co zajmuje dużo więcej czasu niż wykonywanie tych instrukcji), przechodzi do funkcji, a ponieważ nie ma użytkownika, dodaje jeden. Ma sens?

UPDATE Jest to właściwy sposób robienia tego w JavaScript.

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(); 
      } 

     } 
    }); 
} 

Answer 3

Dodaj unikalne ograniczenie do wiadomości e-mail i nie musisz już sprawdzać, czy użytkownik już istnieje!