Zapisywanie wielu dokumentów za pomocą mangusty i robienie czegoś, gdy ostatni raz jest zapisany.

Question

Chcę zapisać 8 obiektów do bazy danych MongoDB za pomocą mangusty. Po zapisaniu ostatniego dokumentu chcę zgłosić (tzn. Wysłać wydarzenie), że wszystkie dokumenty zostały zapisane.

Sposób, w jaki teraz to robię jest dość brudny (szczególnie w przypadku coraz większej ilości dokumentów, które chcę zapisać).

Oto, jak to mam teraz (tylko dla 4 osób w tym przykładzie). Czy istnieje jakiś czystszy sposób, który możesz polecić?

person1.save(function(err, result){ 
    if (err) console.log(err); 
    else{ 
     person2.save(function(err, result){ 
      if (err) console.log(err); 
      else{ 
       person3.save(function(err, result){ 
        if (err) console.log(err); 
        else{ 
         person4.save(function(err, result){ 
          if (err) console.log(err); 
          else{ 
           done(); 
          } 
         }); 
        } 
       }); 
      } 
     }); 
    } 
}); 

Answer 1

Przydatny biblioteki do koordynowania operacji asynchronicznych jest async. W twoim przypadku, kod będzie wyglądał tak:

var people = [ person1, person2, person3, person4, ... ]; 

async.eachSeries(people, function(person, asyncdone) { 
    person.save(asyncdone); 
}, function(err) { 
    if (err) return console.log(err); 
    done(); // or `done(err)` if you want the pass the error up 
}); 

Answer 2

Chciałbym użyć Underscore Each do iteracji na tablicy modeli People. Doprowadziłoby to do tego, że Twój kod byłby czystszy i pomógłbyś uniknąć kodu "boomerang effect".

Z documentation:

.each (lista, iteratee [okolicznościach]) alias: forEach

iteracyjnie listę elementów, dostarczające każdy z kolei funkcją iteratee. Iteratee jest związany z obiektem kontekstu, jeśli został przekazany. Każde wywołanie iteratee wywoływane jest trzema argumentami: (element, indeks, lista). Jeśli list jest obiektem JavaScript, argumentami iteratee będą (wartość, klucz, lista). Zwraca listę do łączenia.

Na przykład:

var people = [person1, person2]; 
var length = people.length; 
var hasError = false; 

var doSomething = function() { 
    console.log('I'm done'); 
} 

var doSomethingElse = function() { 
    console.log('There was an error'); 
} 

_.each(people, function(person, i) { 

    if (!hasError) { 

     person.save(function(err, result) { 
      if (err) { 
       console.log(err); 
       hasError = true; 
      } 
     ); 

     if (i === length) { 
      doSomething(); 
     } 

    } else { 

     // There was an error 
     doSomethingElse(); 
    } 

}); 

Answer 3

Polecam mieć tablicę i zapisać z iteracji. Będzie miał taką samą wydajność, ale kod będzie czystszy.

Można mieć

var Person = mongoose.model('Person'); 
var people = []; 

people[0] = new Person({id: 'someid'}); 
people[0].set('name', 'Mario'); 
people[1] = new Person({id: 'someid'}); 
people[1].set('name', 'Mario'); 
people[2] = new Person({id: 'someid'}); 
people[2].set('name', 'Mario'); 

var errors = []; 
for(person in people){ 
people[person].save(function(err, done){ 
    if(err) errors.push(err); 
    if (person === people.length){ yourCallbackFunction(errors){ 
    if (errors.length!=0) console.log(errors); 
    //yourcode here 
    }; 
    } 
}); 
} 

Answer 4

Najlepszym sposobem jest użycie asynchronicznych waterfall. Część fragmentu kodu może wyglądać jak poniżej. Proszę zapoznać się z powyższym linkiem. Przełamuje on asynchroniczną naturę i przekształca się w jeden po drugim procesie (jeśli się nie mylę).

waterfall([ 
    function(callback){ 
callback(null, 'one', 'two'); 
}, 
    function(arg1, arg2, callback){ 
    callback(null, 'three'); 
    }, 
    function(arg1, callback){ 
// arg1 now equals 'three' 
    callback(null, 'done'); 
    } 
], function (err, result) { 
    // result now equals 'done' 
}); 

Answer 5

Korzystanie obietnice i Array.map()

const userPromises = persons.map(user => { 
    return new Promise((resolve, reject) => { 
    person.save((error, result) => { 
     if (error) { 
     reject(error) 
     } 
     resolve(result); 
    }) 
    }) 
}); 

Promise.all(userPromises).then((results) => { 
    //yay! 
    //results = [first, second, etc...] 
}, (error) => { 
    //nay! 
})