क्या पहला या आखिरी मैच मिल सकता है?

हाँ, आप .findOne() जैसा कि मूल ड्राइवर प्रलेखन में सबसे अच्छा दिखाया गया है। अंतर केवल इतना है कि नेवला कार्यान्वयन में "विकल्प" दस्तावेज़ होना चाहिए विधि को दिया गया "तीसरा" तर्क हो।

तो आप इसके लिए एक "सॉर्ट" विनिर्देश प्रदान कर सकते हैं जैसा कि उपलब्ध विकल्पों में दिखाया गया है:

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

केवल अतिरिक्त जानकारी के लिए आप इसे MongoDB शेल में निम्न के साथ $orderby क्वेरी विकल्प:

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

साथ ही .findOne() विधि केवल एक दस्तावेज़ लौटा सकती है, लेकिन यह वास्तव में .find() . के आसपास केवल एक आवरण है इसलिए सभी संशोधक लागू होते हैं। रैपिंग सिर्फ .next() calls को कॉल करता है लौटाए गए कर्सर पर, दस्तावेज़ लौटाता है और कर्सर को छोड़ देता है।

यह लंबा उदाहरण विभिन्न तरीकों को दिखाता है जिसमें इसे लागू किया जा सकता है:

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