mongodb - sort - nodejs mongoose count




Как рисовать с помощью Mongoose в Node.js? (11)

Вот версия, которую я прикрепляю ко всем моим моделям. Это зависит от подчеркивания для удобства и асинхронности производительности. Опционы позволяют выбирать и сортировать поля, используя синтаксис мангуста.

var _ = require('underscore');
var async = require('async');

function findPaginated(filter, opts, cb) {
  var defaults = {skip : 0, limit : 10};
  opts = _.extend({}, defaults, opts);

  filter = _.extend({}, filter);

  var cntQry = this.find(filter);
  var qry = this.find(filter);

  if (opts.sort) {
    qry = qry.sort(opts.sort);
  }
  if (opts.fields) {
    qry = qry.select(opts.fields);
  }

  qry = qry.limit(opts.limit).skip(opts.skip);

  async.parallel(
    [
      function (cb) {
        cntQry.count(cb);
      },
      function (cb) {
        qry.exec(cb);
      }
    ],
    function (err, results) {
      if (err) return cb(err);
      var count = 0, ret = [];

      _.each(results, function (r) {
        if (typeof(r) == 'number') {
          count = r;
        } else if (typeof(r) != 'number') {
          ret = r;
        }
      });

      cb(null, {totalCount : count, results : ret});
    }
  );

  return qry;
}

Прикрепите его к вашей схеме модели.

MySchema.statics.findPaginated = findPaginated;

Я пишу webapp с Node.js и mongoose. Как я могу разбивать на страницы результаты, полученные из .find() ? Я бы хотел, чтобы функциональность была сопоставима с "LIMIT 50,100" в SQL.


Вы можете использовать skip () и limit (), но это очень неэффективно. Лучшим решением будет сортировка по индексированному полю плюс limit (). Мы в Wunderflats опубликовали небольшую библиотеку здесь: https://github.com/wunderflats/goosepage Он использует первый способ.


Вы можете написать такой запрос.

mySchema.find().skip((page-1)*per_page).limit(per_page).exec(function(err, articles) {
        if (err) {
            return res.status(400).send({
                message: err
            });
        } else {
            res.json(articles);
        }
    });

страница: номер страницы, поступающий от клиента в качестве параметров запроса.
per_page: нет результатов, показанных на странице

Если вы используете стек MEAN после сообщения в блоге, он предоставляет большую часть информации для создания разбивки на страницы в конце, используя бутстрап с угловым пользовательским интерфейсом, и используя методы пропусков и ограничений mongoose в бэкэнд.

см .: https://techpituwa.wordpress.com/2015/06/06/mean-js-pagination-with-angular-ui-bootstrap/


Вы можете цеплять так:

var query = Model.find().sort('mykey', 1).skip(2).limit(5)

Выполните запрос с помощью exec

query.exec(callback);

Лучше поздно, чем никогда.

var pageOptions = {
    page: req.query.page || 0,
    limit: req.query.limit || 10
}

sexyModel.find()
    .skip(pageOptions.page*pageOptions.limit)
    .limit(pageOptions.limit)
    .exec(function (err, doc) {
        if(err) { res.status(500).json(err); return; };
        res.status(200).json(doc);
    })

В этом случае вы можете добавить page запроса и / или limit свой URL-адрес http. Пример ?page=0&limit=25

BTW Pagination начинается с 0


Наилучший подход (ИМО) заключается в использовании пропусков и ограничений, но в ограниченных коллекциях или документах.

Чтобы сделать запрос в рамках ограниченных документов, мы можем использовать определенный индекс как индекс в поле типа DATE. См. Ниже

let page = ctx.request.body.page || 1
let size = ctx.request.body.size || 10
let DATE_FROM = ctx.request.body.date_from
let DATE_TO = ctx.request.body.date_to

var start = (parseInt(page) - 1) * parseInt(size)

let result = await Model.find({ created_at: { $lte: DATE_FROM, $gte: DATE_TO } })
    .sort({ _id: -1 })
    .select('<fields>')
    .skip( start )
    .limit( size )        
    .exec(callback)

После более пристального изучения API Mongoose с информацией, предоставленной Rodolphe, я понял это решение:

MyModel.find(query, fields, { skip: 10, limit: 5 }, function(err, results) { ... });

Разбивка страницы с использованием мангуста, экспресс и нефрита - http://madhums.me/2012/08/20/pagination-using-mongoose-express-and-jade/

var perPage = 10
  , page = Math.max(0, req.param('page'))

Event.find()
    .select('name')
    .limit(perPage)
    .skip(perPage * page)
    .sort({
        name: 'asc'
    })
    .exec(function(err, events) {
        Event.count().exec(function(err, count) {
            res.render('events', {
                events: events,
                page: page,
                pages: count / perPage
            })
        })
    })

Это пример примера, который вы можете попробовать,

var _pageNumber = 2,
  _pageSize = 50;

Student.count({},function(err,count){
  Student.find({}, null, {
    sort: {
      Name: 1
    }
  }).skip(_pageNumber > 0 ? ((_pageNumber - 1) * _pageSize) : 0).limit(_pageSize).exec(function(err, docs) {
    if (err)
      res.json(err);
    else
      res.json({
        "TotalCount": count,
        "_Array": docs
      });
  });
 });

Это то, что я сделал по коду

var paginate = 20;
var page = pageNumber;
MySchema.find({}).sort('mykey', 1).skip((pageNumber-1)*paginate).limit(paginate)
    .exec(function(err, result) {
        // Write some stuff here
    });

Вот как я это сделал.


app.get("/:page",(req,res)=>{
        post.find({}).then((data)=>{
            let per_page = 5;
            let num_page = Number(req.params.page);
            let max_pages = Math.ceil(data.length/per_page);
            if(num_page == 0 || num_page > max_pages){
                res.render('404');
            }else{
                let starting = per_page*(num_page-1)
                let ending = per_page+starting
                res.render('posts', {posts:data.slice(starting,ending), pages: max_pages, current_page: num_page});
            }
        });
});






mongoose