Comment trier la mangouste?

Je ne trouve pas de doc pour le modificateur de tri. Le seul aperçu se trouve dans les tests unitaires: spec.lib.query.js # L12

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

Mais ça ne marche pas pour moi:

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

Dans Mongoose, un tri peut être effectué de l'une des manières suivantes:

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) { ... });

C'est ainsi que j'ai réussi à travailler dans mongoose 2.3.0 :)

// 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
})

À partir de Mongoose 3.8.x:

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

Où:

criteriapeut être asc, desc, ascending, descending, 1ou-1

METTRE À JOUR:

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

Essayer:

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

Mongoose v5.4.3

trier par ordre croissant

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) { ... });

trier par ordre décroissant

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) { ... });

Pour plus de détails: https://mongoosejs.com/docs/api.html#query_Query-sort

Mettre à jour

Il y a une meilleure rédaction si cela déroute les gens; consultez la recherche de documents et le fonctionnement des requêtes dans le manuel de la mangouste. Si vous souhaitez utiliser l'API fluide, vous pouvez obtenir un objet de requête en ne fournissant pas de rappel à la find()méthode, sinon vous pouvez spécifier les paramètres comme je l'explique ci-dessous.

Original

Étant donné un modelobjet, selon les documents sur Model , voici comment cela peut fonctionner pour 2.4.1:

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

L' search specattend un objet, mais vous pouvez passer nullou un objet vide.

Le deuxième paramètre est la liste des champs sous forme de tableau de chaînes, vous devez donc fournir ['field','field2']ou null.

Le troisième paramètre est les options en tant qu'objet, ce qui inclut la possibilité de trier l'ensemble de résultats. Vous utiliseriez { sort: { field: direction } }où fieldest la chaîne fieldname test(dans votre cas) et directionest un nombre où 1est croissant et -1décroissant.

Le paramètre final ( callback) est la fonction de rappel qui reçoit la collection de documents renvoyée par la requête.

L' Model.find()implémentation (dans cette version) fait une allocation glissante de propriétés pour gérer les paramètres optionnels (ce qui m'a dérouté!):

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

C'est ainsi que j'ai pu travailler dans mongoose.js 2.0.4

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

Chaînage avec l'interface du générateur de requêtes dans 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
})

Consultez la documentation pour en savoir plus sur les requêtes.

avec la version actuelle de mongoose (1.6.0) si vous ne voulez trier que par une colonne, vous devez déposer le tableau et passer l'objet directement à la fonction sort ():

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

m'a pris du temps, pour bien faire les choses :(

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

Production

[ { _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 } ]

Voici comment j'ai réussi à trier et à remplir:

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

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

D'autres ont fonctionné pour moi, mais cela a fonctionné:

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

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

C'est ce que j'ai fait, ça marche bien.

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

À partir de la version 4.x, les méthodes de tri ont été modifiées. Si vous utilisez> 4.x. Essayez d'utiliser l'un des éléments suivants.

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) { ... });

Post.find().sort('updatedAt').exec((err, post) => {...});