17

我正在使用 mongoose 将一些数据插入 mongodb。代码如下所示：

var mongoose = require('mongoose');
mongoose.connect('mongo://localhost/test');
var conn = mongoose.connection;

// insert users
conn.collection('users').insert([{/*user1*/},{/*user2*/}], function(err, docs) {
    var user1 = docs[0], user2 = docs[1];

    // insert channels
    conn.collection('channels').insert([{userId:user1._id},{userId:user2._id}], function(err, docs) {
        var channel1 = docs[0], channel2 = docs[1];

        // insert articles
        conn.collection('articles').insert([{userId:user1._id,channelId:channel1._id},{}], function(err, docs) {
            var article1 = docs[0], article2 = docs[1];

        }
    });
};

你可以看到那里有很多嵌套的回调，所以我正在尝试使用q来重构它。

我希望代码看起来像：

Q.fcall(step1)
.then(step2)
.then(step3)
.then(step4)
.then(function (value4) {
    // Do something with value4
}, function (error) {
    // Handle any error from step1 through step4
})
.end();

但我不知道该怎么做。

4

5 回答 5

13

您需要使用README和 Wiki中的Q.nfcall文档。所有的 Mongoose 方法都是 Node 风格的。我还将使用而不是手动解构。.spread.then

var mongoose = require('mongoose');
mongoose.connect('mongo://localhost/test');
var conn = mongoose.connection;

var users = conn.collection('users');
var channels = conn.collection('channels');
var articles = conn.collection('articles');

function getInsertedArticles() {
    return Q.nfcall(users.insert.bind(users), [{/*user1*/},{/*user2*/}]).spread(function (user1, user2) {
        return Q.nfcall(channels.insert.bind(channels), [{userId:user1._id},{userId:user2._id}]).spread(function (channel1, channel2) {
            return Q.nfcall(articles.insert.bind(articles), [{userId:user1._id,channelId:channel1._id},{}]);
        });
    })
}

getInsertedArticles()
    .spread(function (article1, article2) {
        // you only get here if all three of the above steps succeeded
    })
    .fail(function (error) {
        // you get here if any of the above three steps failed
    }
);

在实践中，您很少会想要使用.spread，因为您通常会插入一个您不知道其大小的数组。在这种情况下，代码可能看起来更像这样（这里我也说明了Q.nbind）。

与原始版本比较不太公平，因为您的原始版本没有错误处理。原版的更正节点样式版本如下所示：

var mongoose = require('mongoose');
mongoose.connect('mongo://localhost/test');
var conn = mongoose.connection;

function getInsertedArticles(cb) {
    // insert users
    conn.collection('users').insert([{/*user1*/},{/*user2*/}], function(err, docs) {
        if (err) {
            cb(err);
            return;
        }

        var user1 = docs[0], user2 = docs[1];

        // insert channels
        conn.collection('channels').insert([{userId:user1._id},{userId:user2._id}], function(err, docs) {
            if (err) {
                cb(err);
                return;
            }

            var channel1 = docs[0], channel2 = docs[1];

            // insert articles
            conn.collection('articles').insert([{userId:user1._id,channelId:channel1._id},{}], function(err, docs) {
                if (err) {
                    cb(err);
                    return;
                }

                var article1 = docs[0], article2 = docs[1];

                cb(null, [article1, article2]);
            }
        });
    };
}

getInsertedArticles(function (err, articles) {
    if (err) {
        // you get here if any of the three steps failed.
        // `articles` is `undefined`.
    } else {
        // you get here if all three succeeded.
        // `err` is null.
    }
});
于 2012-05-11T14:54:38.247 回答
4

使用替代的延迟承诺实现，您可以执行以下操作：

var mongoose = require('mongoose');
mongoose.connect('mongo://localhost/test');
var conn = mongoose.connection;

// Setup 'pinsert', promise version of 'insert' method
var promisify = require('deferred').promisify
mongoose.Collection.prototype.pinsert = promisify(mongoose.Collection.prototype.insert);

var user1, user2;
// insert users
conn.collection('users').pinsert([{/*user1*/},{/*user2*/}])
// insert channels
.then(function (users) {
  user1 = users[0]; user2 = users[1];
  return conn.collection('channels').pinsert([{userId:user1._id},{userId:user2._id}]);
})
// insert articles
.match(function (channel1, channel2) {
  return conn.collection('articles').pinsert([{userId:user1._id,channelId:channel1._id},{}]);
})
.done(function (articles) {
  // Do something with articles
}, function (err) {
   // Handle any error that might have occurred on the way
});
于 2012-05-11T16:08:19.547 回答
3

考虑Model.save而不是Collection.insert（在我们的例子中完全一样）。

你不需要使用Q，你可以自己包装save方法并直接返回一个Mongoose Promise。

首先创建一个实用方法来包装保存函数，这不是很干净，但类似于：

  //Utility function (put it in a better place)
  var saveInPromise = function (model) {

    var promise = new mongoose.Promise();

    model.save(function (err, result) {
      promise.resolve(err, result);
    });

    return promise;
  }

然后你可以使用它而不是 save 来链接你的承诺

  var User = mongoose.model('User');
  var Channel = mongoose.model('Channel');
  var Article = mongoose.model('Article');

  //Step 1
  var user = new User({data: 'value'});
  saveInPromise(user).then(function () {

    //Step 2
    var channel = new Channel({user: user.id})
    return saveInPromise(channel);

  }).then(function (channel) {

    //Step 3
    var article = new Article({channel: channel.id})
    return saveInPromise(article);

  }, function (err) {
    //A single place to handle your errors

  });

我想这就是我们正在寻找的那种简单……对吧？当然，实用功能可以通过与 Mongoose 更好的集成来实现。

让我知道你对此有何看法。

顺便说一下，Mongoose Github 中有一个关于这个确切问题的问题：

我希望它会很快得到解决。我认为这需要一些时间，因为他们正在考虑从mpromise切换到Q：请参阅此处和此处。

于 2013-12-09T16:24:47.827 回答
2

两年后，这个问题刚刚出现在我的 RSS 客户端...

自 2012 年 5 月以来，事情发生了一些变化，我们现在可能会选择以不同的方式解决这个问题。更具体地说，自从决定Array.prototype.reduce在 ECMAScript5 中包含（和其他数组方法）以来，Javascript 社区已经变得“具有减少意识”。Array.prototype.reduce一直（并且仍然）可以作为 polyfill 使用，但当时我们中的许多人都很少欣赏它。当然，那些走在曲线前面的人可能会反对这一点。

问题中提出的问题似乎是公式化的，规则如下：

  • 数组中的对象作为第一个参数传递，conn.collection(table).insert()构建如下（其中N对应于对象在数组中的索引）：
    • [ {}, ... ]
    • [ {userId:userN._id}, ... ]
    • [ {userId:userN._id, channelId:channelN._id}, ... ]
  • 表名（按顺序）是 : users, channels, articles.
  • 对应的对象属性是 : user, channel, article（即不带复数“s”的表名）。

Taoofcode的这篇文章中的一个通用模式，用于进行串行异步调用：

function workMyCollection(arr) {  
    return arr.reduce(function(promise, item) {
        return promise.then(function(result) {
            return doSomethingAsyncWithResult(item, result);
        });        
    }, q());
}

通过非常轻松的适应，可以使用此模式来编排所需的顺序：

function cascadeInsert(tables, n) {
    /* 
    /* tables: array of unpluralisd table names
    /* n: number of users to insert.
    /* returns promise of completion|error
     */
    var ids = []; // this outer array is available to the inner functions (to be read and written to).
    for(var i=0; i<n; i++) { ids.push({}); } //initialize the ids array with n plain objects.
    return tables.reduce(function (promise, t) {
        return promise.then(function (docs) {
            for(var i=0; i<ids.length; i++) {
                if(!docs[i]) throw (new Error(t + ": returned documents list does not match the request"));//or simply `continue;` to be error tolerant (if acceptable server-side).
                ids[i][t+'Id'] = docs[i]._id; //progressively add properties to the `ids` objects
            }
            return insert(ids, t + 's');
        });
    }, Q());
}

最后，这是返回承诺的工作函数insert()：

function insert(ids, t) {
    /* 
    /* ids: array of plain objects with properties as defined by the rules
    /* t: table name.
    /* returns promise of docs
     */
    var dfrd = Q.defer();
    conn.collection(t).insert(ids, function(err, docs) {
        (err) ? dfrd.reject(err) : dfrd.resolve(docs);
    });
    return dfrd.promise;
}

因此，您可以指定传递给cascadeInsert的参数、实际表/属性名称和要插入的用户数。

cascadeInsert( ['user', 'channel', 'article'], 2 ).then(function () {
   // you get here if everything was successful
}).catch(function (err) {
   // you get here if anything failed
});

这很好用，因为问题中的表格都有常规复数形式（用户 => 用户，频道 => 频道）。如果其中任何一个是不规则的（例如刺激 => 刺激，孩子 => 孩子），那么我们需要重新考虑 - （并且可能实现查找哈希）。无论如何，适应将是相当微不足道的。

于 2014-04-14T19:41:51.247 回答
1

今天我们也有mongoose-q。一个 mongoose 插件，它为您提供诸如 execQ 和 saveQ 之类的东西，它们返回 Q 承诺。

于 2014-09-17T11:53:46.590 回答