Wie sortiere ich Mungo?

Ich finde kein Dokument für den Sortiermodifikator. Die einzige Erkenntnis sind die Unit-Tests: spec.lib.query.js # L12

writer.limit(5).sort(['test', 1]).group('name')

Aber bei mir funktioniert es nicht:

Post.find().sort(['updatedAt', 1]);

In Mongoose kann eine Sortierung auf eine der folgenden Arten durchgeführt werden:

Post.find({}).sort('test').exec(function(err, docs) { ... });
Post.find({}).sort([['date', -1]]).exec(function(err, docs) { ... });
Post.find({}).sort({test: 1}).exec(function(err, docs) { ... });
Post.find({}, null, {sort: {date: 1}}, function(err, docs) { ... });

So kam ich dazu, in Mungo 2.3.0 zu arbeiten :)

// Find First 10 News Items
News.find({
    deal_id:deal._id // Search Filters
},
['type','date_added'], // Columns to Return
{
    skip:0, // Starting Row
    limit:10, // Ending Row
    sort:{
        date_added: -1 //Sort by Date Added DESC
    }
},
function(err,allNews){
    socket.emit('news-load', allNews); // Do something with the array of 10 objects
})

Ab Mungo 3.8.x:

model.find({ ... }).sort({ field : criteria}).exec(function(err, model){ ... });

Wo:

criteriasein kann asc, desc, ascending, descending, 1, oder-1

AKTUALISIEREN:

Post.find().sort({'updatedAt': -1}).all((posts) => {
  // do something with the array of posts
});

Versuchen:

Post.find().sort([['updatedAt', 'descending']]).all((posts) => {
  // do something with the array of posts
});

Mungo v5.4.3

nach aufsteigender Reihenfolge sortieren

Post.find({}).sort('field').exec(function(err, docs) { ... });
Post.find({}).sort({ field: 'asc' }).exec(function(err, docs) { ... });
Post.find({}).sort({ field: 'ascending' }).exec(function(err, docs) { ... });
Post.find({}).sort({ field: 1 }).exec(function(err, docs) { ... });

Post.find({}, null, {sort: { field : 'asc' }}), function(err, docs) { ... });
Post.find({}, null, {sort: { field : 'ascending' }}), function(err, docs) { ... });
Post.find({}, null, {sort: { field : 1 }}), function(err, docs) { ... });

nach absteigender Reihenfolge sortieren

Post.find({}).sort('-field').exec(function(err, docs) { ... });
Post.find({}).sort({ field: 'desc' }).exec(function(err, docs) { ... });
Post.find({}).sort({ field: 'descending' }).exec(function(err, docs) { ... });
Post.find({}).sort({ field: -1 }).exec(function(err, docs) { ... });


Post.find({}, null, {sort: { field : 'desc' }}), function(err, docs) { ... });
Post.find({}, null, {sort: { field : 'descending' }}), function(err, docs) { ... });
Post.find({}, null, {sort: { field : -1 }}), function(err, docs) { ... });

Für Details: https://mongoosejs.com/docs/api.html#query_Query-sort

Aktualisieren

Es gibt ein besseres Schreiben, wenn dies die Leute verwirrt; Besuche Dokumente zu finden , und wie Abfragen arbeiten im Mungo - Handbuch. Wenn Sie die fließende API verwenden möchten, können Sie ein Abfrageobjekt abrufen, indem Sie keinen Rückruf für die find()Methode bereitstellen. Andernfalls können Sie die Parameter wie unten beschrieben angeben.

Original

Bei einem bestimmten modelObjekt kann es gemäß den Dokumenten zu Model folgendermaßen funktionieren 2.4.1:

Post.find({search-spec}, [return field array], {options}, callback)

Das search specerwartet ein Objekt, aber Sie können nulloder ein leeres Objekt übergeben.

Der zweite Parameter ist die Feldliste als Array von Zeichenfolgen, also würden Sie ['field','field2']oder angeben null.

Der dritte Parameter sind die Optionen als Objekt, einschließlich der Möglichkeit, die Ergebnismenge zu sortieren. Sie würden verwenden, { sort: { field: direction } }wo fieldist der Feldname der Zeichenfolge test(in Ihrem Fall) und directionist eine Zahl, bei der 1aufsteigend und -1absteigend ist.

Der letzte Parameter ( callback) ist die Rückruffunktion, die die von der Abfrage zurückgegebene Sammlung von Dokumenten empfängt.

Die Model.find()Implementierung (in dieser Version) führt eine verschiebbare Zuweisung von Eigenschaften durch, um optionale Parameter zu verarbeiten (was mich verwirrt hat!):

Model.find = function find (conditions, fields, options, callback) {
  if ('function' == typeof conditions) {
    callback = conditions;
    conditions = {};
    fields = null;
    options = null;
  } else if ('function' == typeof fields) {
    callback = fields;
    fields = null;
    options = null;
  } else if ('function' == typeof options) {
    callback = options;
    options = null;
  }

  var query = new Query(conditions, options).select(fields).bind(this, 'find');

  if ('undefined' === typeof callback)
    return query;

  this._applyNamedScope(query);
  return query.find(callback);
};

HTH

So kam ich dazu, in mongoose.js 2.0.4 zu arbeiten

var query = EmailModel.find({domain:"gmail.com"});
query.sort('priority', 1);
query.exec(function(error, docs){
  //...
});

Verkettung mit der Query Builder-Oberfläche in Mongoose 4.

// Build up a query using chaining syntax. Since no callback is passed this will create an instance of Query.
var query = Person.
    find({ occupation: /host/ }).
    where('name.last').equals('Ghost'). // find each Person with a last name matching 'Ghost'
    where('age').gt(17).lt(66).
    where('likes').in(['vaporizing', 'talking']).
    limit(10).
    sort('-occupation'). // sort by occupation in decreasing order
    select('name occupation'); // selecting the `name` and `occupation` fields


// Excute the query at a later time.
query.exec(function (err, person) {
    if (err) return handleError(err);
    console.log('%s %s is a %s.', person.name.first, person.name.last, person.occupation) // Space Ghost is a talk show host
})

Weitere Informationen zu Abfragen finden Sie in den Dokumenten .

Wenn Sie mit der aktuellen Version von mongoose (1.6.0) nur nach einer Spalte sortieren möchten , müssen Sie das Array löschen und das Objekt direkt an die Funktion sort () übergeben:

Content.find().sort('created', 'descending').execFind( ... );

Ich habe einige Zeit gebraucht, um das richtig zu machen :(

app.get('/getting',function(req,res){
    Blog.find({}).limit(4).skip(2).sort({age:-1}).then((resu)=>{
        res.send(resu);
        console.log(resu)
        // console.log(result)
    })
})

Ausgabe

[ { _id: 5c2eec3b8d6e5c20ed2f040e, name: 'e', age: 5, __v: 0 },
  { _id: 5c2eec0c8d6e5c20ed2f040d, name: 'd', age: 4, __v: 0 },
  { _id: 5c2eec048d6e5c20ed2f040c, name: 'c', age: 3, __v: 0 },
  { _id: 5c2eebf48d6e5c20ed2f040b, name: 'b', age: 2, __v: 0 } ]

So konnte ich sortieren und füllen:

Model.find()
.sort('date', -1)
.populate('authors')
.exec(function(err, docs) {
    // code here
})

Post.find().sort({updatedAt: 1});

Andere arbeiteten für mich, aber das tat:

  Tag.find().sort('name', 1).run(onComplete);

Post.find().sort({updatedAt:1}).exec(function (err, posts){
...
});

Das habe ich getan, es funktioniert gut.

User.find({name:'Thava'}, null, {sort: { name : 1 }})

Ab 4.x wurden die Sortiermethoden geändert. Wenn Sie> 4.x verwenden. Versuchen Sie es mit einer der folgenden Methoden.

Post.find({}).sort('-date').exec(function(err, docs) { ... });
Post.find({}).sort({date: -1}).exec(function(err, docs) { ... });
Post.find({}).sort({date: 'desc'}).exec(function(err, docs) { ... });
Post.find({}).sort({date: 'descending'}).exec(function(err, docs) { ... });
Post.find({}).sort([['date', -1]]).exec(function(err, docs) { ... });
Post.find({}, null, {sort: '-date'}, function(err, docs) { ... });
Post.find({}, null, {sort: {date: -1}}, function(err, docs) { ... });