Я пишу webapp с Node.js и mongoose. Как я могу разбивать на страницы результаты, полученные из вызова .find()? Я хотел бы функциональность, сравнимую с "LIMIT 50,100" в SQL.
Как paginate с Mongoose в Node.js?
Ответ 1
После более пристального изучения API Mongoose с информацией, предоставленной Rodolphe, я понял это решение:
MyModel.find(query, fields, { skip: 10, limit: 5 }, function(err, results) { ... });
Ответ 2
Я очень разочарован принятыми ответами в этом вопросе. Это не будет масштабироваться. Если вы прочитали мелкий шрифт на cursor.skip():
Метод cursor.skip() часто дорог, потому что он требует, чтобы сервер шел от начала коллекции или индекса, чтобы получить смещение или пропустить позицию, прежде чем начать возвращать результат. По мере увеличения смещения (например, pageNumber выше) курсор .skip() будет работать медленнее и интенсивнее. С большими коллекциями cursor.skip() может стать привязанным к IO.
Чтобы достичь масштабирования с разбивкой по страницам, объедините предел() вместе с по меньшей мере одним критерием фильтра, дата createdOn подходит для многих целей.
MyModel.find( { createdOn: { $lte: request.createdOnBefore } } )
.limit( 10 )
.sort( '-createdOn' )
Ответ 3
Разбивка на страницы с использованием мангуста, экспресса и нефрита - Здесь ссылка на мой блог с более подробной информацией
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
})
})
})
Ответ 4
Вы можете цеплять так:
var query = Model.find().sort('mykey', 1).skip(2).limit(5)
Выполните запрос с помощью exec
query.exec(callback);
Ответ 5
Вы можете использовать небольшой пакет под названием Mongoose Paginate, который облегчает его.
$ npm install mongoose-paginate
После того, как в ваших маршрутах или контроллере просто добавьте:
/**
* querying for `all` {} items in `MyModel`
* paginating by second page, 10 items per page (10 results, page 2)
**/
MyModel.paginate({}, 2, 10, function(error, pageCount, paginatedResults) {
if (error) {
console.error(error);
} else {
console.log('Pages:', pageCount);
console.log(paginatedResults);
}
}
Ответ 6
Лучше поздно, чем никогда.
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
Пагинация начинается с 0
Ответ 7
Вот пример, который вы можете попробовать,
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
});
});
});
Ответ 8
Попробуйте использовать функцию мангуста для разбивки на страницы. Ограничение - это количество записей на странице и номер страницы.
var limit = parseInt(body.limit);
var skip = (parseInt(body.page)-1) * parseInt(limit);
db.Rankings.find({})
.sort('-id')
.limit(limit)
.skip(skip)
.exec(function(err,wins){
});
Ответ 9
Это то, что я сделал это в коде
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
});
Вот как я это сделал.
Ответ 10
Вот версия, которую я прикрепляю ко всем моим моделям. Это зависит от подчеркивания для удобства и асинхронности производительности. Опционы позволяют выбирать и сортировать поля, используя синтаксис мангуста.
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;
Ответ 11
Над ответом остается в силе.
Просто дополнение для тех, кто любит асинхронное ожидание, а не обещание!
const findAllFoo = async (req, resp, next) => {
const pageSize = 10;
const currentPage = 1;
try {
const foos = await FooModel.find() // find all documents
.skip(pageSize * (currentPage - 1)) // we will not retrieve all records, but will skip first 'n' records
.limit(pageSize); // will limit/restrict the number of records to display
const numberOfFoos = await FooModel.countDocuments(); // count the number of records for that model
resp.setHeader('max-records', numberOfFoos);
resp.status(200).json(foos);
} catch (err) {
resp.status(500).json({
message: err
});
}
};
Ответ 12
Вы также можете использовать следующую строку кода
per_page = parseInt(req.query.per_page) || 10
page_no = parseInt(req.query.page_no) || 1
var pagination = {
limit: per_page ,
skip:per_page * (page_no - 1)
}
users = await User.find({<CONDITION>}).limit(pagination.limit).skip(pagination.skip).exec()
этот код будет работать в последней версии Монго
Ответ 13
Самый простой и быстрый способ - разбивать на страницы с помощью objectId Пример
Условие начальной нагрузки
condition = {limit:12, type:""};
Возьмите первый и последний ObjectId из данных ответа
Страница следующего условия
condition = {limit:12, type:"next", firstId:"57762a4c875adce3c38c662d", lastId:"57762a4c875adce3c38c6615"};
Страница следующего условия
condition = {limit:12, type:"next", firstId:"57762a4c875adce3c38c6645", lastId:"57762a4c875adce3c38c6675"};
В мангусте
var condition = {};
var sort = { _id: 1 };
if (req.body.type == "next") {
condition._id = { $gt: req.body.lastId };
} else if (req.body.type == "prev") {
sort = { _id: -1 };
condition._id = { $lt: req.body.firstId };
}
var query = Model.find(condition, {}, { sort: sort }).limit(req.body.limit);
query.exec(function(err, properties) {
return res.json({ "result": result);
});
Ответ 14
Наилучший подход (ИМО) заключается в использовании пропусков и ограничений, но в ограниченных коллекциях или документах.
Чтобы сделать запрос в рамках ограниченных документов, мы можем использовать определенный индекс как индекс в поле типа 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)
Ответ 15
Самый простой плагин для нумерации страниц.
https://www.npmjs.com/package/mongoose-paginate-v2
Добавьте плагин в схему, а затем используйте метод paginate модели:
var mongoose = require('mongoose');
var mongoosePaginate = require('mongoose-paginate-v2');
var mySchema = new mongoose.Schema({
/* your schema definition */
});
mySchema.plugin(mongoosePaginate);
var myModel = mongoose.model('SampleModel', mySchema);
myModel.paginate().then({}) // Usage
Ответ 16
Это примерная функция для получения результата модели умений с опциями пагинации и ограничения
export function get_skills(req, res){
console.log('get_skills');
var page = req.body.page; // 1 or 2
var size = req.body.size; // 5 or 10 per page
var query = {};
if(page < 0 || page === 0)
{
result = {'status': 401,'message':'invalid page number,should start with 1'};
return res.json(result);
}
query.skip = size * (page - 1)
query.limit = size
Skills.count({},function(err1,tot_count){ //to get the total count of skills
if(err1)
{
res.json({
status: 401,
message:'something went wrong!',
err: err,
})
}
else
{
Skills.find({},{},query).sort({'name':1}).exec(function(err,skill_doc){
if(!err)
{
res.json({
status: 200,
message:'Skills list',
data: data,
tot_count: tot_count,
})
}
else
{
res.json({
status: 401,
message: 'something went wrong',
err: err
})
}
}) //Skills.find end
}
});//Skills.count end
}
Ответ 17
Простое и мощное решение для нумерации страниц
last_doc_id: последний идентификатор документа, который вы получаете
no_of_docs_required: количество документов, которые вы хотите получить, т.е. 5, 10, 50 и т.д.
async getNextDocs(no_of_docs_required: number, last_doc_id?: string) {
let docs
if (!last_doc_id) {
// get first 5 docs
docs = await MySchema.find().sort({ _id: -1 }).limit(no_of_docs_required)
}
else {
// get next 5 docs according to that last document id
docs = await MySchema.find({_id: {$lt: last_doc_id}})
.sort({ _id: -1 }).limit(no_of_docs_required)
}
return docs
}
- Если вы не предоставите последний идентификатор документа для метода, вы получите 5 последних документов
- Если вы указали последний идентификатор документа, вы получите следующие 5 документов.
Ответ 18
Вы можете написать такой запрос.
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);
}
});
page: номер страницы, поступающий от клиента в качестве параметров запроса.
per_page: нет результатов, показанных на странице
Если вы используете стек MEAN после сообщения в блоге, он предоставляет большую часть информации для создания разбивки на страницы в конце, используя angular -UI bootstrap и используя методы пропуска mongoose и ограничения в бэкэнд.
см. https://techpituwa.wordpress.com/2015/06/06/mean-js-pagination-with-angular-ui-bootstrap/
Ответ 19
Вы можете использовать skip() и limit(), но это очень неэффективно. Лучшим решением будет сортировка по индексированному полю плюс limit(). Мы в Wunderflats опубликовали небольшую библиотеку здесь: https://github.com/wunderflats/goosepage Он использует первый способ.
Ответ 20
Если вы используете мангуст в качестве источника для спокойного api, посмотрите 'restify-mongoose' и его запросы. Он имеет именно эту функциональность.
Любой запрос в коллекции предоставляет заголовки, которые здесь полезны.
test-01:~$ curl -s -D - localhost:3330/data?sort=-created -o /dev/null
HTTP/1.1 200 OK
link: </data?sort=-created&p=0>; rel="first", </data?sort=-created&p=1>; rel="next", </data?sort=-created&p=134715>; rel="last"
.....
Response-Time: 37
Таким образом, вы получаете общий сервер с относительно линейным временем загрузки запросов к коллекциям. Это потрясающе и что-то, на что можно смотреть, если вы хотите перейти в собственную реализацию.
Ответ 21
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});
}
});
});
Ответ 22
**//localhost:3000/asanas/?pageNo=1&size=3**
//requiring asanas model
const asanas = require("../models/asanas");
const fetchAllAsanasDao = () => {
return new Promise((resolve, reject) => {
var pageNo = parseInt(req.query.pageNo);
var size = parseInt(req.query.size);
var query = {};
if (pageNo < 0 || pageNo === 0) {
response = {
"error": true,
"message": "invalid page number, should start with 1"
};
return res.json(response);
}
query.skip = size * (pageNo - 1);
query.limit = size;
asanas
.find(pageNo , size , query)
.then((asanasResult) => {
resolve(asanasResult);
})
.catch((error) => {
reject(error);
});
});
}
Ответ 23
Также удалось достичь результатов с помощью async/await.
Пример кода ниже с использованием асинхронного обработчика с hapi v17 и mongoose v5
{
method: 'GET',
path: '/api/v1/paintings',
config: {
description: 'Get all the paintings',
tags: ['api', 'v1', 'all paintings']
},
handler: async (request, reply) => {
/*
* Grab the querystring parameters
* page and limit to handle our pagination
*/
var pageOptions = {
page: parseInt(request.query.page) - 1 || 0,
limit: parseInt(request.query.limit) || 10
}
/*
* Apply our sort and limit
*/
try {
return await Painting.find()
.sort({dateCreated: 1, dateModified: -1})
.skip(pageOptions.page * pageOptions.limit)
.limit(pageOptions.limit)
.exec();
} catch(err) {
return err;
}
}
}
Ответ 24
Используйте этот простой плагин.
https://github.com/WebGangster/mongoose-paginate-v2
Установка
npm install mongoose-paginate-v2