我专门使用 mongoose，尽管我认为这没有那么重要。例如，假设我有一个名为 MongoQueue 的集合，我向该队列添加了一些人。

`MongoQueue.save {function(err, firstPerson) {
   if (err) console.log(err);
   MongoQueue.save {function(err, secondPerson) {
      if (err) console.log(err);
      MongoQueue.save {function(err, thirdPerson) {
         if (err) console.log(err);
}}}`

如何检索最先保存到 MongoQueue 的人？或者.... mongoDB 的 findOne() 方法如何缩小搜索范围？我可以指定 findOne() 的行为来选择集合中最旧的文档吗？或者我必须对集合进行排序(这是最后的手段)，如果是这样，我将如何按时间戳排序？

最佳答案

是的，您可以指定 .findOne() 的行为如 native 驱动程序文档中所示。唯一的区别是在 Mongoose 实现中，“选项”文档必须是传递给方法的“第三个”参数。

因此您可以为此提供“排序”规范，如可用选项所示:

Queue.findOne({ },null,{ "sort": { "_id": -1 } },function(err,doc) {

只是为了获得更多信息，您可以在 MongoDB shell 中使用以下命令执行此操作，使用 $orderby查询选项:

db.collection.findOne({ "$query": { }, "$orderby": { "_id": -1 } })

此外，.findOne() 方法可能只返回一个文档，但它实际上只是 .find() 的包装器，因此所有修饰符都适用。包装只是在返回的游标上调用 .next()，返回文档并丢弃游标。

这个较长的示例展示了应用它的不同方式:

var async = require('async'),
    mongoose = require('mongoose'),
    Schema = mongoose.Schema;


mongoose.connect('mongodb://localhost/sequence');

var queueSchema = new Schema({
  name: String,
  same: { type: String, default: "same" }
});

var Queue = mongoose.model( "Queue", queueSchema );

var count = 0;

async.series(
  [

    // Remove any documents
    function(callback) {
      Queue.remove(function(err) {
        if (err) throw err;
        callback();
      });
    },

    // Insert some new ones
    function(callback) {
      async.eachSeries(
        ["one","two","three"],
        function(item,callback) {
          var queue = new Queue({ name: item });
          queue.save(function(err,doc) {
            if (err) throw err;
            console.dir(doc);
            callback(err,doc);
          });
        },
        function(err) {
          callback(err);
        }
      );
    },

    function(callback) {
      async.whilst(
        function() { return count < 2 },
        function(callback) {
          count++
          async.series(
            [
              // findOne is just the first one
              function(callback) {
                Queue.findOne({ "same": "same" },function(err,doc) {
                  if (err) throw err;
                  console.log( "FindOne:\n%s", doc );
                  callback();
                });
              },

              // Or is sorted
              function(callback) {
                Queue.findOne(
                  { "same": "same" },
                  null,
                  { "sort": { "_id": -1 } },
                  function(err,doc) {
                    if (err) throw err;
                    console.log("FindOne last:\n%s", doc );
                    callback();
                  }
                );
              },

              // find is ordered but not singular
              function(callback) {
                async.eachSeries(
                  ["first","last"],
                  function(label,callback) {
                    var direction = ( label == "first" ) ? 1 : -1;
                    var query = Queue.find({ "same": "same" })
                      .sort({ "_id": direction })
                      .limit(1);
                    query.exec(function(err,docs) {
                      if (err) throw err;
                      console.log( ".find() %s:\n%s", label, docs[0] );
                      callback();
                    });
                  },
                  function(err) {
                    callback();
                  }
                );
              },

              // findAndModify takes a sort
              function(callback) {
                Queue.findOneAndUpdate(
                  { "same": "same" },
                  { "$set": { "same": "different" } },
                  { "sort": { "_id": -1 } },
                  function(err,doc) {
                    if (err) throw err;
                    console.log( "findOneAndUpdate:\n%s", doc );
                    callback();
                  }
                );
              }

            ],function(err) {
              callback();
            }
          );
        },
        function(err) {
          callback();
        }
      );
    }
  ],function(err) {
    console.log("done");1
    mongoose.disconnect();
  }
);

关于javascript - findOne 可以匹配第一个还是最后一个？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/24792758/