entityMap|blocks|key|9sjrj|text|在仔细研究了Mongoose+API和Rodolphe提供的信息之后，我找到了这个解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|88fiq|MyModel.find(query,+fields,+{+skip:+10,+limit:+5+},+function(err,+results)+{+...+});|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

After taking a closer look at the Mongoose API with the information provided by Rodolphe, I figured out this solution:

<pre><code>MyModel.find(query, fields, { skip: 10, limit: 5 }, function(err, results) { ... });
</code></pre>

entityMap|blocks|key|qv4c|text|我对这个问题中被接受的答案感到非常失望。这将无法扩展。如果您阅读了cursor.skip(+)上的详细说明：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|dgpn1|cursor.skip()方法通常开销很大，因为它需要服务器从集合或索引的开头遍历以获取偏移量或跳过位置，然后才开始返回结果。随着偏移量(例如上面的pageNumber+)的增加，cursor.skip()将变得更慢并占用更多的CPU。对于较大的集合，cursor.skip()可能会变成IO绑定。|1sar4|6ta0k|为了以可伸缩的方式实现分页，结合使用limit(+)和至少一个筛选条件，createdOn日期适合多种用途。|4611m|MyModel.find(+{+createdOn:+{+$lte:+request.createdOnBefore+}+}+)
.limit(+10+)
.sort(+'-createdOn'+)|code-block|syntax|javascript^0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|M|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|N|9|@]|A|@]|B|$]]|$2|E|4|-4|6|7|8|O|9|@]|A|@]|B|$]]|$2|F|4|G|6|7|8|P|9|@]|A|@]|B|$]]|$2|H|4|I|6|J|8|Q|9|@]|A|@]|B|$K|L]]]]

I'm am very disappointed by the accepted answers in this question. This will not scale. If you read the fine print on cursor.skip( ):

<blockquote>
 The cursor.skip() method is often expensive because it requires the server to walk from the beginning of the collection or index to get the offset or skip position before beginning to return result. As offset (e.g. pageNumber above) increases, cursor.skip() will become slower and more CPU intensive. With larger collections, cursor.skip() may become IO bound.
</blockquote>

To achieve pagination in a scaleable way combine a limit( ) along with at least one filter criterion, a createdOn date suits many purposes. 

<pre><code>MyModel.find( { createdOn: { $lte: request.createdOnBefore } } )
.limit( 10 )
.sort( '-createdOn' )
</code></pre>

entityMap|blocks|key|c9kvg|text|使用mongoose，express和jade进行分页-|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1f24f|这里有一个我的博客的链接，里面有更多的细节|56obq|var+perPage+=+10
++,+page+=+Math.max(0,+req.params.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
++++++++++++})
++++++++})
++++})|code-block|syntax|javascript^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|J|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|K|9|@]|A|@]|B|$]]|$2|E|4|F|6|G|8|L|9|@]|A|@]|B|$H|I]]]]

Pagination using mongoose, express and jade - <a href="http://madhums.me/2012/08/20/pagination-using-mongoose-express-and-jade/" rel="noreferrer">Here's a link to my blog with more detail</a>

<pre><code>var perPage = 10
 , page = Math.max(0, req.params.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
 })
 })
 })
</code></pre>

entityMap|blocks|key|hf11|text|你可以像这样链接：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1eck3|var+query+=+Model.find().sort('mykey',+1).skip(2).limit(5)|code-block|syntax|javascript|bmg22|使用以下命令执行查询|533pq|query.exec(callback);^0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|L|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|M|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|N|9|@]|A|@]|B|$]]|$2|J|4|K|6|E|8|O|9|@]|A|@]|B|$F|G]]]]

You can chain just like that:

<pre><code>var query = Model.find().sort('mykey', 1).skip(2).limit(5)
</code></pre>

Execute the query using <code>exec</code>

<pre><code>query.exec(callback);
</code></pre>

entityMap|blocks|key|8gagm|text|在这种情况下，您可以添加查询|type|unstyled|depth|inlineStyleRanges|entityRanges|data|94dm|和/或|bi141|作为查询字符串添加到您的URL。|8hq7n|例如：|7koh2|cj1um|f9ev|因为它将是一个|dulfu|我们需要将它转换为|fnkdk|用于我们的计算。让我们使用|1qo4v|方法，让我们也提供一些默认值。|c7vu3|const+pageOptions+=+{
++++page:+parseInt(req.query.page,+10)+%7C%7C+0,
++++limit:+parseInt(req.query.limit,+10)+%7C%7C+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);
++++});|code-block|syntax|javascript|ets4|顺便说一句|5oibv|分页以^0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|11|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|12|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|13|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|14|9|@]|A|@]|B|$]]|$2|I|4|-4|6|7|8|15|9|@]|A|@]|B|$]]|$2|J|4|-4|6|7|8|16|9|@]|A|@]|B|$]]|$2|K|4|L|6|7|8|17|9|@]|A|@]|B|$]]|$2|M|4|N|6|7|8|18|9|@]|A|@]|B|$]]|$2|O|4|P|6|7|8|19|9|@]|A|@]|B|$]]|$2|Q|4|R|6|7|8|1A|9|@]|A|@]|B|$]]|$2|S|4|T|6|U|8|1B|9|@]|A|@]|B|$V|W]]|$2|X|4|Y|6|7|8|1C|9|@]|A|@]|B|$]]|$2|Z|4|10|6|7|8|1D|9|@]|A|@]|B|$]]]]

In this case, you can add the query <code>page</code> and/ or <code>limit</code> to your URL as a query string. 

For example: 
<code>?page=0&amp;limit=25 // this would be added onto your URL: http:localhost:5000?page=0&amp;limit=25</code> 

Since it would be a <code>String</code> we need to convert it to a <code>Number</code> for our calculations. Let's do it using the <code>parseInt</code> method and let's also provide some default values.

<pre><code>const pageOptions = {
 page: parseInt(req.query.page, 10) || 0,
 limit: parseInt(req.query.limit, 10) || 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);
 });
</code></pre>

BTW 
Pagination starts with <code>0</code>

entityMap|blocks|key|6sqn3|text|您可以使用一个名为|type|unstyled|depth|inlineStyleRanges|entityRanges|data|a91iq|Mongoose+Paginate|ejunt|这让它变得更容易。|epc9m|$+npm+install+mongoose-paginate|code-block|syntax|javascript|bongm|在路由或控制器中之后，只需添加：|6jc2g|/**
+*+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);
++}
}^0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|P|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|Q|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|R|9|@]|A|@]|B|$]]|$2|G|4|H|6|I|8|S|9|@]|A|@]|B|$J|K]]|$2|L|4|M|6|7|8|T|9|@]|A|@]|B|$]]|$2|N|4|O|6|I|8|U|9|@]|A|@]|B|$J|K]]]]

You can use a little package called <a href="https://github.com/edwardhotchkiss/mongoose-paginate" rel="noreferrer">Mongoose Paginate</a> that makes it easier.

<pre><code>$ npm install mongoose-paginate
</code></pre>

After in your routes or controller, just add :

<pre><code>/**
 * 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);
 }
}
</code></pre>

entityMap|blocks|key|82jh9|text|查询：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|59our|search+=+productName|code-block|syntax|javascript|anl74|参数：|8vsgi|page+=+1|mp5o|//+Pagination
router.get("/search/:page",+(req,+res,+next)+=>+{
++++const+resultsPerPage+=+5;
++++let+page+=+req.params.page+>=+1+?+req.params.page+:+1;
++++const+query+=+req.query.search;

++++page+=+page+-+1

++++Product.find({+name:+query+})
++++++++.select("name")
++++++++.sort({+name:+"asc"+})
++++++++.limit(resultsPerPage)
++++++++.skip(resultsPerPage+*+page)
++++++++.then((results)+=>+{
++++++++++++return+res.status(200).send(results);
++++++++})
++++++++.catch((err)+=>+{
++++++++++++return+res.status(500).send(err);
++++++++});
});^0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|N|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|O|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|P|9|@]|A|@]|B|$]]|$2|J|4|K|6|E|8|Q|9|@]|A|@]|B|$F|G]]|$2|L|4|M|6|E|8|R|9|@]|A|@]|B|$F|G]]]]

Query:
<pre><code>search = productName
</code></pre>
Params:
<pre><code>page = 1 
</code></pre>
<hr />
<pre><code>// Pagination
router.get(&quot;/search/:page&quot;, (req, res, next) =&gt; {
 const resultsPerPage = 5;
 let page = req.params.page &gt;= 1 ? req.params.page : 1;
 const query = req.query.search;

 page = page - 1

 Product.find({ name: query })
 .select(&quot;name&quot;)
 .sort({ name: &quot;asc&quot; })
 .limit(resultsPerPage)
 .skip(resultsPerPage * page)
 .then((results) =&gt; {
 return res.status(200).send(results);
 })
 .catch((err) =&gt; {
 return res.status(500).send(err);
 });
});
</code></pre>

entityMap|blocks|key|bcc13|text|这是一个示例，你可以试一下。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|ds0o2|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
++++++});
++});
+});|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

This is a sample example you can try this,



<pre class="lang-js prettyprint-override"><code>var _pageNumber = 2,
 _pageSize = 50;

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

entityMap|blocks|key|617oe|text|尝试使用mongoose函数进行分页。Limit是每页的记录数和页数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|fl5bk|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){
+});|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

Try using mongoose function for pagination. Limit is the number of records per page and number of the page.

<pre><code>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){
 });
</code></pre>

entityMap|blocks|key|lqa5|text|这就是我在代码中所做的|type|unstyled|depth|inlineStyleRanges|entityRanges|data|6tchu|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
++++});|code-block|syntax|javascript|ahbnc|我就是这么做的。^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|J|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|K|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|L|9|@]|A|@]|B|$]]]]

This is what I done it on code

<pre><code>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
 });
</code></pre>

That is how I done it.

entityMap|blocks|key|756qf|text|有一些很好的答案给出了使用skip()+&+limit()的解决方案，但是，在某些场景中，我们还需要documents+count来生成分页。以下是我们在项目中所做的工作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|ah801|const+PaginatePlugin+=+(schema,+options)+=>+{
++options+=+options+%7C%7C+{}
++schema.query.paginate+=+async+function(params)+{
++++const+pagination+=+{
++++++limit:+options.limit+%7C%7C+10,
++++++page:+1,
++++++count:+0
++++}
++++pagination.limit+=+parseInt(params.limit)+%7C%7C+pagination.limit
++++const+page+=+parseInt(params.page)
++++pagination.page+=+page+>+0+?+page+:+pagination.page
++++const+offset+=+(pagination.page+-+1)+*+pagination.limit

++++const+[data,+count]+=+await+Promise.all([
++++++this.limit(pagination.limit).skip(offset),
++++++this.model.countDocuments(this.getQuery())
++++]);
++++pagination.count+=+count;
++++return+{+data,+pagination+}
++}
}

mySchema.plugin(PaginatePlugin,+{+limit:+DEFAULT_LIMIT+})

//+using+async/await
const+{+data,+pagination+}+=+await+MyModel.find(...)
++.populate(...)
++.sort(...)
++.paginate({+page:+1,+limit:+10+})

//+or+using+Promise
MyModel.find(...).paginate(req.query)
++.then(({+data,+pagination+})+=>+{

++})
++.catch(err+=>+{

++})|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

There are some good answers giving the solution that uses skip() &amp; limit(), however, in some scenarios, we also need documents count to generate pagination. Here's what we do in our projects:
<pre class="lang-js prettyprint-override"><code>const PaginatePlugin = (schema, options) =&gt; {
 options = options || {}
 schema.query.paginate = async function(params) {
 const pagination = {
 limit: options.limit || 10,
 page: 1,
 count: 0
 }
 pagination.limit = parseInt(params.limit) || pagination.limit
 const page = parseInt(params.page)
 pagination.page = page &gt; 0 ? page : pagination.page
 const offset = (pagination.page - 1) * pagination.limit

 const [data, count] = await Promise.all([
 this.limit(pagination.limit).skip(offset),
 this.model.countDocuments(this.getQuery())
 ]);
 pagination.count = count;
 return { data, pagination }
 }
}

mySchema.plugin(PaginatePlugin, { limit: DEFAULT_LIMIT })

// using async/await
const { data, pagination } = await MyModel.find(...)
 .populate(...)
 .sort(...)
 .paginate({ page: 1, limit: 10 })

// or using Promise
MyModel.find(...).paginate(req.query)
 .then(({ data, pagination }) =&gt; {

 })
 .catch(err =&gt; {

 })
</code></pre>

entityMap|blocks|key|fpsfe|text|这是一个我附加到我所有模型上的版本。它依赖于下划线的方便性和异步的性能。opts允许使用mongoose语法进行字段选择和排序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|63aec|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;
}|code-block|syntax|javascript|53qvn|将其附加到您的模型架构。|8dofs|MySchema.statics.findPaginated+=+findPaginated;^0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|L|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|M|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|N|9|@]|A|@]|B|$]]|$2|J|4|K|6|E|8|O|9|@]|A|@]|B|$F|G]]]]

Here is a version that I attach to all my models. It depends on underscore for convenience and async for performance. The opts allows for field selection and sorting using the mongoose syntax.

<pre><code>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;
}
</code></pre>

Attach it to your model schema.

<pre><code>MySchema.statics.findPaginated = findPaginated;
</code></pre>

entityMap|blocks|key|aarag|text|上面的答案是成立的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|9gom|对于任何喜欢异步的人来说，这只是一个附加组件--等待而不是承诺！|f0u2k|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
++++++++});
++++}
};|code-block|syntax|javascript^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|J|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|K|9|@]|A|@]|B|$]]|$2|E|4|F|6|G|8|L|9|@]|A|@]|B|$H|I]]]]

Above answer's holds good. 

<blockquote>
 Just an add-on for anyone who is into async-await rather than
 promise !!
</blockquote>

<pre><code>const findAllFoo = async (req, resp, next) =&gt; {
 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
 });
 }
};
</code></pre>

entityMap|blocks|key|a7up|text|简单而强大的分页解决方案|type|unstyled|depth|inlineStyleRanges|entityRanges|data|96ssv|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
}|code-block|syntax|javascript|bol5o|：您获得的最后一个文档id|dp3jt|：要获取的文档数量，如5、10、50等。|cuslj|如果您不提供|bnvvj|对于该方法，您将获得例如5个最新的文档|f74aj|如果您提供了|9tp2p|然后你会得到下一个，也就是5个文档。^0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|T|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|U|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|V|9|@]|A|@]|B|$]]|$2|J|4|K|6|7|8|W|9|@]|A|@]|B|$]]|$2|L|4|M|6|7|8|X|9|@]|A|@]|B|$]]|$2|N|4|O|6|7|8|Y|9|@]|A|@]|B|$]]|$2|P|4|Q|6|7|8|Z|9|@]|A|@]|B|$]]|$2|R|4|S|6|7|8|10|9|@]|A|@]|B|$]]]]

Simple and powerful pagination solution

<pre><code>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
}
</code></pre>

<code>last_doc_id</code>: the last document id that you get

<code>no_of_docs_required</code>: the number of docs that you want to fetch i.e. 5, 10, 50 etc.

<ol>
<li>If you don't provide the <code>last_doc_id</code> to the method, you'll get i.e. 5 latest docs</li>
<li>If you've provided the <code>last_doc_id</code> then you'll get the next i.e. 5 documents.</li>
</ol>

entityMap|blocks|key|1vop0|text|您也可以使用以下代码行|type|unstyled|depth|inlineStyleRanges|entityRanges|data|7sf0k|per_page+=+parseInt(req.query.per_page)+%7C%7C+10
page_no+=+parseInt(req.query.page_no)+%7C%7C+1
var+pagination+=+{
++limit:+per_page+,
++skip:per_page+*+(page_no+-+1)
}
users+=+await+User.find({}).limit(pagination.limit).skip(pagination.skip).exec()|code-block|syntax|javascript|87s2b|此代码可以在最新版本的mongo中运行^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|J|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|K|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|L|9|@]|A|@]|B|$]]]]

you can use the following line of code as well

<pre><code>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({&lt;CONDITION&gt;}).limit(pagination.limit).skip(pagination.skip).exec()
</code></pre>

this code will work in latest version of mongo

entityMap|blocks|key|8g64o|text|要实现这一点，一种可靠的方法是从前端使用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|8uq6t|查询字符串|9ip29|..。假设我们想要|42hu5|页面|fs6n6|eh2nb|#2|4d1l1|还有|6fhi8|限制|fkifd|输出到|bfee1|25个结果|96fq9|..。|436ls|查询字符串将如下所示：|4mcmu|2d4f4|让我们看看代码：|dfj8g|//+We+would+receive+the+values+with+req.query.<>++=>+e.g.+req.query.page
//+Since+it+would+be+a+String+we+need+to+convert+it+to+a+Number+in+order+to+do+our
//+necessary+calculations.+Let's+do+it+using+the+parseInt()+method+and+let's+also+provide+some+default+values:

++const+page+=+parseInt(req.query.page,+10)+%7C%7C+1;+//+getting+the+'page'+value
++const+limit+=+parseInt(req.query.limit,+10)+%7C%7C+25;+//+getting+the+'limit'+value
++const+startIndex+=+(page+-+1)+*+limit;+//+this+is+how+we+would+calculate+the+start+index+aka+the+SKIP+value
++const+endIndex+=+page+*+limit;+//+this+is+how+we+would+calculate+the+end+index

//+We+also+need+the+'total'+and+we+can+get+it+easily+using+the+Mongoose+built-in+**countDocuments**+method
++const+total+=+await+<>.countDocuments();

//+skip()+will+return+a+certain+number+of+results+after+a+certain+number+of+documents.
//+limit()+is+used+to+specify+the+maximum+number+of+results+to+be+returned.

//+Let's+assume+that+both+are+set+(if+that's+not+the+case,+the+default+value+will+be+used+for)

++query+=+query.skip(startIndex).limit(limit);

++//+Executing+the+query
++const+results+=+await+query;

++//+Pagination+result+
+//+Let's+now+prepare+an+object+for+the+frontend
++const+pagination+=+{};

//+If+the+endIndex+is+smaller+than+the+total+number+of+documents,+we+have+a+next+page
++if+(endIndex+<+total)+{
++++pagination.next+=+{
++++++page:+page+%2B+1,
++++++limit
++++};
++}

//+If+the+startIndex+is+greater+than+0,+we+have+a+previous+page
++if+(startIndex+>+0)+{
++++pagination.prev+=+{
++++++page:+page+-+1,
++++++limit
++++};
++}

+//+Implementing+some+final+touches+and+making+a+successful+response+(Express.js)

const+advancedResults+=+{
++++success:+true,
++++count:+results.length,
++++pagination,
++++data:+results
+}
//+That's+it.+All+we+have+to+do+now+is+send+the+`results`+to+the+frontend.
+res.status(200).json(advancedResults);|code-block|syntax|javascript|fmt6u|我建议将此逻辑实现到中间件中，以便您能够将其用于各种路由/控制器。^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|17|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|18|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|19|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|1A|9|@]|A|@]|B|$]]|$2|I|4|-4|6|7|8|1B|9|@]|A|@]|B|$]]|$2|J|4|K|6|7|8|1C|9|@]|A|@]|B|$]]|$2|L|4|M|6|7|8|1D|9|@]|A|@]|B|$]]|$2|N|4|O|6|7|8|1E|9|@]|A|@]|B|$]]|$2|P|4|Q|6|7|8|1F|9|@]|A|@]|B|$]]|$2|R|4|S|6|7|8|1G|9|@]|A|@]|B|$]]|$2|T|4|U|6|7|8|1H|9|@]|A|@]|B|$]]|$2|V|4|W|6|7|8|1I|9|@]|A|@]|B|$]]|$2|X|4|-4|6|7|8|1J|9|@]|A|@]|B|$]]|$2|Y|4|Z|6|7|8|1K|9|@]|A|@]|B|$]]|$2|10|4|11|6|12|8|1L|9|@]|A|@]|B|$13|14]]|$2|15|4|16|6|7|8|1M|9|@]|A|@]|B|$]]]]

A solid approach to implement this would be to pass the values from the frontend using a query string. Let's say we want to get page #2 and also limit the output to 25 results. 
The query string would look like this: <code>?page=2&amp;limit=25 // this would be added onto your URL: http:localhost:5000?page=2&amp;limit=25</code> 

Let's see the code:

<pre><code>// We would receive the values with req.query.&lt;&lt;valueName&gt;&gt; =&gt; e.g. req.query.page
// Since it would be a String we need to convert it to a Number in order to do our
// necessary calculations. Let's do it using the parseInt() method and let's also provide some default values:

 const page = parseInt(req.query.page, 10) || 1; // getting the 'page' value
 const limit = parseInt(req.query.limit, 10) || 25; // getting the 'limit' value
 const startIndex = (page - 1) * limit; // this is how we would calculate the start index aka the SKIP value
 const endIndex = page * limit; // this is how we would calculate the end index

// We also need the 'total' and we can get it easily using the Mongoose built-in **countDocuments** method
 const total = await &lt;&lt;modelName&gt;&gt;.countDocuments();

// skip() will return a certain number of results after a certain number of documents.
// limit() is used to specify the maximum number of results to be returned.

// Let's assume that both are set (if that's not the case, the default value will be used for)

 query = query.skip(startIndex).limit(limit);

 // Executing the query
 const results = await query;

 // Pagination result 
 // Let's now prepare an object for the frontend
 const pagination = {};

// If the endIndex is smaller than the total number of documents, we have a next page
 if (endIndex &lt; total) {
 pagination.next = {
 page: page + 1,
 limit
 };
 }

// If the startIndex is greater than 0, we have a previous page
 if (startIndex &gt; 0) {
 pagination.prev = {
 page: page - 1,
 limit
 };
 }

 // Implementing some final touches and making a successful response (Express.js)

const advancedResults = {
 success: true,
 count: results.length,
 pagination,
 data: results
 }
// That's it. All we have to do now is send the `results` to the frontend.
 res.status(200).json(advancedResults);
</code></pre>

<hr>

I would suggest implementing this logic into middleware so you can be able to use it for various routes/ controllers.

entityMap|blocks|key|bso43|text|您可以使用mongoose-paginate+v2来执行此操作。了解更多信息|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2uapr|单击此处|d87le|const+mongoose+++++++++=+require('mongoose');
const+mongoosePaginate+=+require('mongoose-paginate-v2');

const+mySchema+=+new+mongoose.Schema({
++++//+your+schema+code
});+
mySchema.plugin(mongoosePaginate);+
const+myModel+=+mongoose.model('SampleModel',++mySchema);

myModel.paginate().then({})+//+Usage|code-block|syntax|javascript^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|J|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|K|9|@]|A|@]|B|$]]|$2|E|4|F|6|G|8|L|9|@]|A|@]|B|$H|I]]]]

You can do using mongoose-paginate-v2. For more info <a href="https://www.npmjs.com/package/mongoose-paginate-v2" rel="nofollow noreferrer">click here</a>
<pre><code>const mongoose = require('mongoose');
const mongoosePaginate = require('mongoose-paginate-v2');

const mySchema = new mongoose.Schema({
 // your schema code
}); 
mySchema.plugin(mongoosePaginate); 
const myModel = mongoose.model('SampleModel', mySchema);

myModel.paginate().then({}) // Usage
</code></pre>

entityMap|blocks|key|dvotk|text|最简单、更快速的方法是，使用objectId示例进行分页；|type|unstyled|depth|inlineStyleRanges|entityRanges|data|fddsk|初始负载条件|f9era|condition+=+{limit:12,+type:""};|code-block|syntax|javascript|4dgsj|从响应数据中获取第一个也是最后一个ObjectId|7m3bh|翻页下一个条件|c518m|condition+=+{limit:12,+type:"next",+firstId:"57762a4c875adce3c38c662d",+lastId:"57762a4c875adce3c38c6615"};|4gdmk|f604g|condition+=+{limit:12,+type:"next",+firstId:"57762a4c875adce3c38c6645",+lastId:"57762a4c875adce3c38c6675"};|7i2l1|在mongoose中|budhj|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);
});^0|0|0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|W|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|X|9|@]|A|@]|B|$]]|$2|E|4|F|6|G|8|Y|9|@]|A|@]|B|$H|I]]|$2|J|4|K|6|7|8|Z|9|@]|A|@]|B|$]]|$2|L|4|M|6|7|8|10|9|@]|A|@]|B|$]]|$2|N|4|O|6|G|8|11|9|@]|A|@]|B|$H|I]]|$2|P|4|M|6|7|8|12|9|@]|A|@]|B|$]]|$2|Q|4|R|6|G|8|13|9|@]|A|@]|B|$H|I]]|$2|S|4|T|6|7|8|14|9|@]|A|@]|B|$]]|$2|U|4|V|6|G|8|15|9|@]|A|@]|B|$H|I]]]]

The easiest and more speedy way is, paginate with the objectId
Example;

Initial load condition

<pre><code>condition = {limit:12, type:""};
</code></pre>

Take the first and last ObjectId from response data

Page next condition

<pre><code>condition = {limit:12, type:"next", firstId:"57762a4c875adce3c38c662d", lastId:"57762a4c875adce3c38c6615"};
</code></pre>

Page next condition

<pre><code>condition = {limit:12, type:"next", firstId:"57762a4c875adce3c38c6645", lastId:"57762a4c875adce3c38c6675"};
</code></pre>

In mongoose

<pre><code>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);
});
</code></pre>

entityMap|blocks|key|b43fj|text|最好的方法(IMO)是使用跳过和限制，但在有限的集合或文档中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|99f70|为了在有限的文档中进行查询，我们可以在日期类型字段上使用特定的索引。请看下面的内容|2d2jl|let+page+=+ctx.request.body.page+%7C%7C+1
let+size+=+ctx.request.body.size+%7C%7C+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('')
++++.skip(+start+)
++++.limit(+size+)++++++++
++++.exec(callback)|code-block|syntax|javascript^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|J|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|K|9|@]|A|@]|B|$]]|$2|E|4|F|6|G|8|L|9|@]|A|@]|B|$H|I]]]]

The best approach (IMO) is to use skip and limit BUT within a limited collections or documents. 

To make the query within limited documents, we can use specific index like index on a DATE type field. See that below

<pre><code>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('&lt;fields&gt;')
 .skip( start )
 .limit( size ) 
 .exec(callback)
</code></pre>

entityMap|blocks|key|qmnr|text|最简单的分页插件。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|889sd|https://www.npmjs.com/package/mongoose-paginate-v2|b91i9|将插件添加到架构中，然后使用模型分页方法：|4kg73|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|code-block|syntax|javascript^0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|L|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|M|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|N|9|@]|A|@]|B|$]]|$2|G|4|H|6|I|8|O|9|@]|A|@]|B|$J|K]]]]

Most easiest plugin for pagination.

<a href="https://www.npmjs.com/package/mongoose-paginate-v2" rel="nofollow noreferrer">https://www.npmjs.com/package/mongoose-paginate-v2</a>

Add plugin to a schema and then use model paginate method:

<pre><code>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
</code></pre>

entityMap|blocks|key|efj6f|text|这是使用分页和限制选项获取技能模型结果的示例函数|type|unstyled|depth|inlineStyleRanges|entityRanges|data|43jff|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+%7C%7C+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|code-block|syntax|javascript|ek7vg|}^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|J|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|K|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|L|9|@]|A|@]|B|$]]]]

This is example function for getting the result of skills model with pagination and limit options

<pre><code> 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 &lt; 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
</code></pre>

}

entityMap|blocks|key|epeha|text|let+page,limit,skip,lastPage,+query;
+page+=+req.params.page+*1+%7C%7C+1;++//This+is+the+page,fetch+from+the+server
+limit+=+req.params.limit+*+1+%7C%7C+1;+//++This+is+the+limit+,it+also+fetch+from+the+server
+skip+=+(page+-+1)+*+limit;+++//+Number+of+skip+document
+lastPage+=+page+*+limit;+++//last+index+
+counts+=+await+userModel.countDocuments()+//Number+of+document+in+the+collection

query+=+query.skip(skip).limit(limit)+//current+page

const+paginate+=+{}

//For+previous+page
if(skip+>+0)+{
+++paginate.prev+=+{
+++++++page:+page+-+1,
+++++++limit:+limit
}+
//For+next+page
+if(lastPage+<+counts)+{
++paginate.next+=+{
+++++page:+page+%2B+1,
+++++limit:+limit
}
results+=+await+query+//Here+is+the+final+results+of+the+query.|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript^0^^$0|$]|1|@$2|3|4|5|6|7|8|E|9|@]|A|@]|B|$C|D]]]]

<pre><code>let page,limit,skip,lastPage, query;
 page = req.params.page *1 || 1; //This is the page,fetch from the server
 limit = req.params.limit * 1 || 1; // This is the limit ,it also fetch from the server
 skip = (page - 1) * limit; // Number of skip document
 lastPage = page * limit; //last index 
 counts = await userModel.countDocuments() //Number of document in the collection

query = query.skip(skip).limit(limit) //current page

const paginate = {}

//For previous page
if(skip &gt; 0) {
 paginate.prev = {
 page: page - 1,
 limit: limit
} 
//For next page
 if(lastPage &lt; counts) {
 paginate.next = {
 page: page + 1,
 limit: limit
}
results = await query //Here is the final results of the query.
</code></pre>

entityMap|blocks|key|50os8|text|您可以像这样编写查询。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|ddf51|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);
++++++++}
++++});|code-block|syntax|javascript|bbsm7|page+:来自客户端的页码，作为请求参数。|8lmag|每|580kb|_|fj24o|页面:每页显示的结果数|df68b|如果你使用的是MEAN+stack，下面的博客帖子提供了在前端使用angular-UI+bootstrap和在后端使用mongoose、skip和limit方法创建分页的许多信息。|eaaeo|请参见：|hu31|https://techpituwa.wordpress.com/2015/06/06/mean-js-pagination-with-angular-ui-bootstrap/^0|0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|V|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|W|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|X|9|@]|A|@]|B|$]]|$2|J|4|K|6|7|8|Y|9|@]|A|@]|B|$]]|$2|L|4|M|6|7|8|Z|9|@]|A|@]|B|$]]|$2|N|4|O|6|7|8|10|9|@]|A|@]|B|$]]|$2|P|4|Q|6|7|8|11|9|@]|A|@]|B|$]]|$2|R|4|S|6|7|8|12|9|@]|A|@]|B|$]]|$2|T|4|U|6|7|8|13|9|@]|A|@]|B|$]]]]

You can write query like this. 

<pre><code>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);
 }
 });
</code></pre>

page : page number coming from client as request parameters. 
per_page : no of results shown per page 

If you are using MEAN stack following blog post provides much of the information to create pagination in front end using angular-UI bootstrap and using mongoose skip and limit methods in the backend.

see : <a href="https://techpituwa.wordpress.com/2015/06/06/mean-js-pagination-with-angular-ui-bootstrap/" rel="nofollow">https://techpituwa.wordpress.com/2015/06/06/mean-js-pagination-with-angular-ui-bootstrap/</a>

entityMap|blocks|key|6a7ff|text|您可以使用skip()和limit()，但它的效率非常低。更好的解决方案是对索引字段进行排序加上limit()。我们Wunderflats在这里发布了一个小lib：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|c3733|https://github.com/wunderflats/goosepage|2r0s1|它使用第一种方法。^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|G|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|H|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|I|9|@]|A|@]|B|$]]]]

You can either use skip() and limit(), but it's very inefficient. A better solution would be a sort on indexed field plus limit(). 
We at Wunderflats have published a small lib here: <a href="https://github.com/wunderflats/goosepage" rel="nofollow">https://github.com/wunderflats/goosepage</a>
It uses the first way.

entityMap|blocks|key|20na3|text|如果您正在使用mongoose作为restful+api的源代码，请查看‘|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4j28q|restify+mongoose|8a9t0|‘及其查询。它正是内置了这个功能。|7mgm7|对集合的任何查询都提供了在此很有帮助的标头|3g3j7|test-01:~$+curl+-s+-D+-+localhost:3330/data?sort=-created+-o+/dev/null
HTTP/1.1+200+OK
link:+;+rel="first",+;+rel="next",+;+rel="last"
.....
Response-Time:+37|code-block|syntax|javascript|2tgsi|所以基本上你得到了一个通用的服务器，查询到集合的加载时间是相对线性的。这真是太棒了，如果你想进入自己的实现中，你可以看看这一点。^0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|P|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|Q|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|R|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|S|9|@]|A|@]|B|$]]|$2|I|4|J|6|K|8|T|9|@]|A|@]|B|$L|M]]|$2|N|4|O|6|7|8|U|9|@]|A|@]|B|$]]]]

If you are using mongoose as a source for a restful api have a look at 
'<a href="https://www.npmjs.com/package/restify-mongoose#queries" rel="nofollow">restify-mongoose</a>' and its queries. It has exactly this functionality built in. 

Any query on a collection provides headers that are helpful here 

<pre><code>test-01:~$ curl -s -D - localhost:3330/data?sort=-created -o /dev/null
HTTP/1.1 200 OK
link: &lt;/data?sort=-created&amp;p=0&gt;; rel="first", &lt;/data?sort=-created&amp;p=1&gt;; rel="next", &lt;/data?sort=-created&amp;p=134715&gt;; rel="last"
.....
Response-Time: 37
</code></pre>

So basically you get a generic server with a relatively linear load time for queries to collections. That is awesome and something to look at if you want to go into a own implementation.

entityMap|blocks|key|1l97e|text|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+%7C%7C+num_page+>+max_pages){
++++++++++++++++res.render('404');
++++++++++++}else{
++++++++++++++++let+starting+=+per_page*(num_page-1)
++++++++++++++++let+ending+=+per_page%2Bstarting
++++++++++++++++res.render('posts',+{posts:data.slice(starting,ending),+pages:+max_pages,+current_page:+num_page});
++++++++++++}
++++++++});
});|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript^0^^$0|$]|1|@$2|3|4|5|6|7|8|E|9|@]|A|@]|B|$C|D]]]]

<pre><code>app.get("/:page",(req,res)=&gt;{
 post.find({}).then((data)=&gt;{
 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 &gt; 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});
 }
 });
});
</code></pre>

entityMap|blocks|key|dmqqh|text|**//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+%7C%7C+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);
++++++++++++});

++++});
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript^0^^$0|$]|1|@$2|3|4|5|6|7|8|E|9|@]|A|@]|B|$C|D]]]]

<pre><code>**//localhost:3000/asanas/?pageNo=1&amp;size=3**

//requiring asanas model
const asanas = require("../models/asanas");


const fetchAllAsanasDao = () =&gt; {
 return new Promise((resolve, reject) =&gt; {

 var pageNo = parseInt(req.query.pageNo);
 var size = parseInt(req.query.size);
 var query = {};
 if (pageNo &lt; 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) =&gt; {
 resolve(asanasResult);
 })
 .catch((error) =&gt; {
 reject(error);
 });

 });
}
</code></pre>

entityMap|blocks|key|4uu4p|text|使用这个简单的插件。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|8jq05|https://github.com/WebGangster/mongoose-paginate-v2|3s57p|安装|cpsvp|​|8ad17|npm+install+mongoose-paginate-v2|code-block|syntax|javascript|dq6ql|用法将插件添加到模式中，然后使用模型分页方法：|6l8h0|9fpd0|b74hu|const+mongoose+++++++++=+require('mongoose');
const+mongoosePaginate+=+require('mongoose-paginate-v2');

const+mySchema+=+new+mongoose.Schema({+
++/*+your+schema+definition+*/+
});

mySchema.plugin(mongoosePaginate);

const+myModel+=+mongoose.model('SampleModel',++mySchema);+

myModel.paginate().then({})+//+Usage|34s4v^0|0|0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|U|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|V|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|W|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|X|9|@]|A|@]|B|$]]|$2|I|4|J|6|K|8|Y|9|@]|A|@]|B|$L|M]]|$2|N|4|O|6|7|8|Z|9|@]|A|@]|B|$]]|$2|P|4|H|6|7|8|10|9|@]|A|@]|B|$]]|$2|Q|4|H|6|7|8|11|9|@]|A|@]|B|$]]|$2|R|4|S|6|K|8|12|9|@]|A|@]|B|$L|M]]|$2|T|4|H|6|7|8|13|9|@]|A|@]|B|$]]]]

Use this simple plugin.

<a href="https://github.com/WebGangster/mongoose-paginate-v2" rel="nofollow noreferrer">https://github.com/WebGangster/mongoose-paginate-v2</a>

Installation

<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-html lang-html prettyprint-override"><code>npm install mongoose-paginate-v2</code></pre>
</div>
</div>

Usage
 Add plugin to a schema and then use model paginate method:

<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-html lang-html prettyprint-override"><code>const mongoose = require('mongoose');
const mongoosePaginate = require('mongoose-paginate-v2');

const mySchema = new mongoose.Schema({ 
 /* your schema definition */ 
});

mySchema.plugin(mongoosePaginate);

const myModel = mongoose.model('SampleModel', mySchema); 

myModel.paginate().then({}) // Usage</code></pre>
</div>
</div>

entityMap|blocks|key|c3sfo|text|使用ts-mongoose分页|type|unstyled|depth|inlineStyleRanges|entityRanges|data|bc495|const+trainers+=+await+Trainer.paginate(
++++++++{+user:+req.userId+},
++++++++{
++++++++++++perPage:+3,
++++++++++++page:+1,
++++++++++++select:+'-password,+-createdAt+-updatedAt+-__v',
++++++++++++sort:+{+createdAt:+-1+},
++++++++}
++++)

++++return+res.status(200).json(trainers)|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

Using ts-mongoose-pagination

<pre><code> const trainers = await Trainer.paginate(
 { user: req.userId },
 {
 perPage: 3,
 page: 1,
 select: '-password, -createdAt -updatedAt -__v',
 sort: { createdAt: -1 },
 }
 )

 return res.status(200).json(trainers)
</code></pre>

entityMap|blocks|key|b8qdt|text|也能够实现异步/等待的结果。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|520am|下面的代码示例使用带有hapi+v17和mongoose+v5的异步处理程序|60evd|{
++++++++++++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+%7C%7C+0,+
++++++++++++++++++++limit:+parseInt(request.query.limit)+%7C%7C+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;
+++++++++++++++}

++++++++++++}
++++++++}|code-block|syntax|javascript^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|J|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|K|9|@]|A|@]|B|$]]|$2|E|4|F|6|G|8|L|9|@]|A|@]|B|$H|I]]]]

Was able to achieve results with async/await as well.

Code example below using an async handler with hapi v17 and mongoose v5

<pre><code>{
 method: 'GET',
 path: '/api/v1/paintings',
 config: {
 description: 'Get all the paintings',
 tags: ['api', 'v1', 'all paintings']
 },
 handler: async (request, reply) =&gt; {
 /*
 * 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;
 }

 }
 }
</code></pre>

I am writing a webapp with Node.js and mongoose. How can I paginate the results I get from a <code>.find()</code> call? I would like a functionality comparable to <code>"LIMIT 50,100"</code> in SQL.

How to paginate with Mongoose in Node.js?

中间件

服务器

路由

 我正在用Node.js和mongoose写一个网页应用。如何对从 打电话？我想要一个可与之相比的功能 在SQL中。

问如何在Node.js中使用Mongoose分页？
EN

回答 30

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Node.js中使用Mongoose分页？EN

回答 30

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Node.js中使用Mongoose分页？
EN