¿Cómo ordenar en mangosta?

No encuentro ningún documento para el modificador de clasificación. La única idea está en las pruebas unitarias: spec.lib.query.js # L12

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

Pero no me funciona:

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

En Mongoose, se puede hacer una clasificación de cualquiera de las siguientes maneras:

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

Así es como conseguí ordenar para trabajar en mangosta 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
})

A partir de Mangosta 3.8.x:

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

Dónde:

criteriapuede ser asc, desc, ascending, descending, 1, o-1

ACTUALIZAR:

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

Tratar:

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

Mangosta v5.4.3

ordenar por orden ascendente

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

ordenar por orden descendente

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

Para detalles: https://mongoosejs.com/docs/api.html#query_Query-sort

Actualizar

Hay una mejor redacción si esto confunde a las personas; consulte la búsqueda de documentos y cómo funcionan las consultas en el manual de mangosta. Si desea utilizar la API fluida, puede obtener un objeto de consulta al no proporcionar una devolución de llamada alfind() método, de lo contrario, puede especificar los parámetros como se detalla a continuación.

Original

Dado un modelobjeto, según los documentos del Modelo , así es como puede funcionar para 2.4.1:

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

El search specespera un objeto, pero puede pasar nullo un objeto vacío.

El segundo parámetro es la lista de campos como una serie de cadenas, por lo que debe proporcionar ['field','field2']o null.

El tercer parámetro son las opciones como un objeto, que incluye la capacidad de ordenar el conjunto de resultados. Se podría utilizar { sort: { field: direction } }donde fieldes el nombre del campo de cadena test(en su caso) y directiones un número donde 1está ascendiendo y -1se desceding.

El param final ( callback) es la función de devolución de llamada que recibe la colección de documentos devueltos por la consulta.

La Model.find()implementación (en esta versión) realiza una asignación deslizante de propiedades para manejar parámetros opcionales (¡lo cual es lo que me confundió!):

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

Así es como me puse a trabajar en mongoose.js 2.0.4

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

Encadenamiento con la interfaz del generador de consultas en 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
})

Consulte los documentos para obtener más información sobre las consultas.

con la versión actual de mangosta (1.6.0) si solo desea ordenar por una columna, debe soltar la matriz y pasar el objeto directamente a la función sort ():

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

me llevó algo de tiempo hacer esto bien :(

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

Salida

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

Así es como logré ordenar y poblar:

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

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

Otros trabajaron para mí, pero esto hizo:

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

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

Esto es lo que hice, funciona bien.

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

A partir de 4.x, los métodos de clasificación han cambiado. Si está usando> 4.x. Intente usar cualquiera de los siguientes.

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