asynchronous iterative patterns in Node.js

also_wrong.js

function insertCollection(collection, callback) {
  for(var i = 0; i < collection.length; i++) {
    (function(i) {
      db.insert(collection[i], function(err) {
        if (err) {
          callback(err);
          return;
        }
        if (i == (collection.length - 1)) {
          callback();
        }
      });
    })(i);
  }
}

right.js

function insertCollection(collection, callback) {
  var inserted = 0;
  for(var i = 0; i < collection.length; i++) {
    db.insert(collection[i], function(err) {
      if (err) {
        callback(err);
        return;
      }
      if (++inserted == collection.length) {
        callback();
      }
    });
  }
}

serialize.js

function insertCollection(collection, callback) {
  var coll = collection.slice(0); // clone collection
  (function insertOne() {
    var record = coll.splice(0, 1)[0]; // get the first record of coll and reduce coll by one
    db.insert(record, function(err) {
      if (err) { callback(err); return }
      if (coll.length == 0) {
        callback();
      } else {
        insertOne();
      }
    }
  })();
}

serialize_timeout.js

function insertCollection(collection, callback) {
  var coll = collection.slice(0); // clone collection
  (function insertOne() {
    var record = coll.splice(0, 1)[0]; // get the first record of coll and reduce coll by one
    db.insert(record, function(err) {
      if (err) { callback(err); return }
      if (coll.length == 0) {
        callback();
      } else {
        setTimeout(insertOne, 0);
      }
    }
  })();
}

serialize_timeout_catch.js

function insertCollection(collection, callback) {
  var coll = collection.slice(0); // clone collection
  (function insertOne() {
    var record = coll.splice(0, 1)[0]; // get the first record of coll and reduce coll by one
    try {
      db.insert(record, function(err) {
        if (err) { callback(err); return }
        if (coll.length == 0) {
          callback();
        } else {
          insertOne();
        }
      }
    } catch (exception) {
      callback(exception);
    }
  })();
}

synchronous.js

function insertCollection(collection) {
  for(var i = 0; i < collection.length; i++) {
    db.insert(collection[i]);
  }
}

wrong.js

function insertCollection(collection, callback) {
  for(var i = 0; i < collection.length; i++) {
    db.insert(collection[i], function(err) {
      if (err) {
        throw err;
      }
    });
  }
  callback();
}

Your article (http://metaduck.com/post/2675027550/asynchronous-iteration-patterns-in-node-js) suggests that the callback is only called after the last insert in the also_wrong example.

I don't think this is correct. "i == (collection.length - 1)" would always be true, thus making it call the callback collection.length times. This illustrates it:

for(var i=0; 10>i; i++) {
  setTimeout(function() {
    console.info(i); // prints out 10, 10 times
  }, 500);
}

Let me know if I'm wrong :)

@RasmusRn Right you are, correctd, thanks!
Should be wrapping the i var inside a closure.
One more reason it's also wrong :)

No problem!

Thanks for the article! :)