Node.js'de Mongoose ile sayfalandırma nasıl yapılır?


232

Node.js ve mongoose ile bir web uygulaması yazıyorum. Bir .find()çağrıdan aldığım sonuçları nasıl sayfalandırabilirim ? "LIMIT 50,100"SQL ile karşılaştırılabilir bir işlevsellik istiyorum .


Koleksiyondan veri bulurken atla ve sınırla özelliğini kullanın.
Arun Sahani

Bu bağlantı sizin için ayrıntılı olarak kullanılabilir. laxmanchavda.blogspot.com/2018/06/…
laxman

Yanıtlar:


278

Bu soruda kabul edilen cevaplardan çok hayal kırıklığına uğradım. Bu ölçeklenmeyecek. İmleç üzerindeki ince baskıyı okursanız. Skip ():

Cursor.skip () yöntemi genellikle pahalıdır çünkü sunucunun sonucu döndürmeye başlamadan önce ofseti veya atlama konumunu almak için koleksiyonun veya dizinin başından yürümesini gerektirir. Ofset (örn. Yukarıdaki pageNumber) arttıkça, cursor.skip () yavaşlar ve CPU yoğunluğu artar. Daha büyük koleksiyonlarda, cursor.skip () IO'ya bağlı olabilir.

Sayfalandırmayı ölçeklenebilir bir şekilde elde etmek için bir limit () ile en az bir filtre ölçütü birleştirin, createOn tarihi birçok amaca uygundur.

MyModel.find( { createdOn: { $lte: request.createdOnBefore } } )
.limit( 10 )
.sort( '-createdOn' )

105
Ancak bu sorgudan ikinci sayfayı nasıl atlarsınız? Sayfa başına 10 sonuç görüntülüyorsanız ve 100 sonuç varsa, ofset veya atlama değerini nasıl tanımlarsınız? Sayfalandırma sorusunu cevaplamıyorsunuz, bu yüzden geçerli bir uyarı olmasına rağmen 'hayal kırıklığına uğramazsınız'. Aynı sorun MySQL dengelemesinde olsa da, sınırlayın. Sonuçları döndürmeden önce ağacı ofsete çevirmek gerekir. Bunu bir tuz tanesi ile alırdım, sonuç kümeleriniz 1mil'den azsa ve korunan bir performans isabeti yoksa, skip () kullanın.
Lex

13
Ben, bu firavunfaresi / MongoDB geldiğinde bir çaylak değilim, ama Lex'in soruyu cevaplamak için görünür sonuçlar 'göre sıralanır olarak, bu -createdOnsize değerini yerine geçecek,' request.createdOnBeforeen az değere sahip createdOn, daha önceki sonuç kümesindeki döndü ve sonra yeniden sorgula.
Terry Lewis

9
@JoeFrambach createdOn tabanlı istekte bulunmak sorunlu görünüyor. Atlama bir nedenden dolayı gömüldü. Belgeler, tüm DBMS'lerde olduğu gibi, btree endeksi üzerinden bisiklete binme performans isabeti hakkında uyarıda bulunur. Kullanıcılar için "MySQL LIMIT 50,100 karşılaştırılabilir bir şey" sorusu için .skip tam olarak doğru.
Lex

8
İlginç olsa da, bu cevapla ilgili bir sorun, @Lex yorum notları olarak, yalnızca sonuçlarda "ileri" veya "geri" atlayabilmenizdir - atlayabileceğiniz "sayfalarınız" olamaz (ör. Sayfa 1, Sayfa 2) , Sayfa 3) sayfalandırmanın nereden başlayacağını belirlemek için birden fazla ardışık sorgu yapmadan , çoğu durumda sadece atlama kullanmaktan daha yavaş olacağından şüpheleniyorum. Tabii ki belirli sayfalara atlama yeteneğini eklemeniz gerekmeyebilir.
Iain Collins

20
Bu cevap ilginç noktalar içeriyor, ancak sorulan orijinal soruya cevap vermiyor.
steampowered

227

Rodolphe tarafından sağlanan bilgilerle Mongoose API'sine daha yakından baktıktan sonra, bu çözümü anladım:

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

21
"Saymak" ne olacak? Kaç sayfa olduğunu bilmek için buna ihtiyacınız var.
Aleksey Saatchi

36
Ölçeklenmez.
Chris Hinkle

4
Chris Hinkle'ın bunun neden ölçeklenmediğine dair açıklaması: stackoverflow.com/a/23640287/165330 .
imme

7
@ChrisHinkle Tüm DBMS'lerde durum böyle. Lex'in bağlantılı cevabın altındaki yorumu daha fazla açıklıyor gibi görünüyor.
csotiriou

2
@Avij evet. Bunun için tanımlayıcı kullandım. orada yaptığınız son kayıt kimliği sunucuya geri göndermek ve gönderilen daha büyük bir kimliğe sahip bazı kayıtları almak. Id endekslendiği için, çok daha hızlı olacak
George Bailey

108

Firavun faresi, ekspres ve yeşim kullanarak sayfalandırma - İşte bloguma daha ayrıntılı bir bağlantı

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

26
Cevabınızı gönderdiğiniz için teşekkürler! Lütfen Kendi Kendini Tanıtma ile ilgili SSS bölümünü dikkatle okuyun. Ayrıca , kendi sitenize / ürününüze her bağlandığınızda bir feragatname yayınlamanız gerektiğini unutmayın .
Andrew Barber

Math.max(0, undefined)Geri dönecek undefined, Bu benim için çalıştı:let limit = Math.abs(req.query.limit) || 10; let page = (Math.abs(req.query.page) || 1) - 1; Schema.find().limit(limit).skip(limit * page)
Monfa.red

55

Aynen böyle zincirleyebilirsiniz:

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

Kullanarak sorguyu yürütün exec

query.exec(callback);

Cevabınız için teşekkür ederim, sonuca geri arama nasıl eklenir?
Thomas

2
execFind (işlev (... örneğin: var page = req.param('p'); var per_page = 10; if (page == null) { page = 0; } Location.count({}, function(err, count) { Location.find({}).skip(page*per_page).limit(per_page).execFind(function(err, locations) { res.render('index', { locations: locations }); }); });
todd

9
not: bu mongoose içinde işe yaramaz , ama mongodb-yerli-sürücüde çalışır.
Jesse

39

Bu durumda, sorguyu pageve / veya limitURL'nizi sorgu dizesi olarak ekleyebilirsiniz .

Örneğin:
?page=0&limit=25 // this would be added onto your URL: http:localhost:5000?page=0&limit=25

Bu olacağı için, hesaplamalarımız için Stringonu a'ya dönüştürmemiz gerekir Number. Bunu parseIntyöntemi kullanarak yapalım ve bazı varsayılan değerler de verelim.

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

BTW Pagination ile başlar0


5
lütfen {{page: parseInt (req.query.page) || 0, ...} parametresine ekleyin.
imalik8088

@ imalik8088 Teşekkürler, ancak AFAIK dize parametreleri otomatik olarak ele alınmaktadır mongoose.
CENT1PEDE

1
Davranışı bekliyordum ama benim durumumda
gizlenemedi

@ imalik8088 Bu çok garip. Belki bir çoğaltma hatası gösterebilirseniz cevabımı düzenleyebilirim. Teşekkürler.
CENT1PEDE

2
Bu, hükümdarın koşulları uygulamadan önce her kaydı bulmasına neden olur mu?
FluffyBeing

37

Mongoose Paginate adında küçük bir paket kullanabilirsiniz .

$ npm install mongoose-paginate

Rotalarınızda veya denetleyicinizde sonra şunları ekleyin:

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

2
Bu optimize edilmiş mi?
Argento

16

Bu, deneyebileceğiniz örnek bir örnek,

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

11

Sayfalandırma için tekdüzen işlevini kullanmayı deneyin. Sınır, sayfa başına kayıt sayısı ve sayfa sayısıdır.

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

10

Kodda yaptığım şey bu

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

Ben böyle yaptım.


1
Toplam sayfa sayısı nasıl elde edilir
Rhushikesh

Merhaba @Rushikesh, Sayımı almak için bir count () işlevi kullanabilirsiniz. Ancak veritabanından başka bir sorgu olması gerekiyor gibi görünüyor. Ayrıntılar burada mongoosejs.com/docs/api.html#model_Model.count
Indra Santosa

@Rushushesh sayımı al ve sınıra
böle

count()kullanımdan kaldırıldı. kullanımcountDocuments()
Ruslan

7

Sorgu;
search = productName,

parametreler;
sayfa = 1

// Pagination
router.get("/search/:page", (req, res, next) => {
  const resultsPerPage = 5;
  const page = req.params.page >= 1 ? req.params.page : 1;
  const query = req.query.search;

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

Bu cevap için teşekkürler; Ben daha yeni olanlardan biriydi çünkü ilk iplik okuduktan sonra denedim. Ancak, bunu uyguladığımda, bir hata keşfettim - şimdi yazıldığı gibi, her zaman sonuçların ilk sayfasını döndürmeyecektir, çünkü DAİMA bir atlama değerine sahip olacaktır. Product.find () çağrısından önce "page = page-1" eklemeyi deneyin.
Interog

6

İşte tüm modellerime eklediğim bir sürüm. Kolaylık için alt çizgiye ve performans için zaman uyumsuzluğa bağlıdır. Ops, mongoose sözdizimini kullanarak alan seçimine ve sıralamaya izin verir.

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

Model şemanıza ekleyin.

MySchema.statics.findPaginated = findPaginated;

6

Basit ve güçlü sayfalama çözümü

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
}

last_doc_id: aldığınız son belge kimliği

no_of_docs_required: getirmek istediğiniz doküman sayısı, yani 5, 10, 50 vb.

  1. last_doc_idYöntemi sağlamazsanız, yani 5 son doküman alırsınız.
  2. Sağladığınız olursa last_doc_ido zaman bir sonraki yani 5 belgelerini alırsınız.

5

Yanıtın üstünde iyi duruyor.

Vaat yerine async-bekleyen herkes için sadece bir eklenti !!

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

4

aşağıdaki kod satırını da kullanabilirsiniz

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

bu kod mongo'nun son sürümünde çalışacaktır


3

Bunu uygulamak için sağlam bir yaklaşım, bir sorgu dizesi kullanarak değerleri ön uçtan geçirmek olacaktır . Diyelim biz almak istiyorum demek sayfa 2. ve ayrıca sınırlamak çıktı 25 sonuçlarla .
Sorgu dizesi şöyle görünecektir:?page=2&limit=25 // this would be added onto your URL: http:localhost:5000?page=2&limit=25

Kodu görelim:

// We would receive the values with req.query.<<valueName>>  => 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 <<modelName>>.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 + 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);

Bu mantığı ara katman yazılımına uygulamayı öneririm, böylece çeşitli yollar / kontrolörler için kullanabilirsiniz.


2

En kolay ve hızlı yol, objectId Örneği ile sayfalamaktır;

İlk yükleme koşulu

condition = {limit:12, type:""};

Yanıt verilerinden ilk ve son ObjectId'i alın

Sonraki sayfa koşulu

condition = {limit:12, type:"next", firstId:"57762a4c875adce3c38c662d", lastId:"57762a4c875adce3c38c6615"};

Sonraki sayfa koşulu

condition = {limit:12, type:"next", firstId:"57762a4c875adce3c38c6645", lastId:"57762a4c875adce3c38c6675"};

Firavun faresinde

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

2

En iyi yaklaşım (IMO) sınırlı koleksiyonlar veya belgeler içinde atlama ve sınırlama AMA kullanmaktır.

Sorguyu sınırlı belgelerde yapmak için DATE türü alanında dizin gibi belirli bir dizin kullanabiliriz. Aşağıya bakın

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)

2

Sayfalandırma için en kolay eklenti.

https://www.npmjs.com/package/mongoose-paginate-v2

Bir şemaya eklenti ekleyin ve ardından model paginate yöntemini kullanın:

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

bu eklenti mongoose v5.5.5 ile bozuldu
Isaac Pak

1

Bu, sayfalama ve sınırlama seçenekleriyle beceri modelinin sonucunu almak için örnek işlevdir

 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

}


0

Böyle bir sorgu yazabilirsiniz.

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

sayfa: istemciden istek parametreleri olarak gelen sayfa numarası.
per_page: sayfa başına gösterilen sonuç sayısı

Eğer blog yazısını takip eden MEAN yığınını kullanıyorsanız, açısal-UI önyükleme kullanarak ve arka uçta tekdüzen atlama ve sınırlama yöntemlerini kullanarak ön uçta sayfalandırma oluşturmak için bilgilerin çoğunu sağlar.

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


0

Skip () ve limit () kullanabilirsiniz, ancak çok verimsizdir. Daha iyi bir çözüm, dizinlenmiş alan artı limit () üzerinde bir sıralama olacaktır. Wunderflats olarak biz burada küçük bir lib yayınladık: https://github.com/wunderflats/goosepage İlk yolu kullanıyor.


0

Firavun faresini dinlendirici bir API için kaynak olarak kullanıyorsanız, ' restify-mongoose ' ve sorgularına göz atın . Tam olarak bu işlevselliğe sahiptir.

Bir koleksiyondaki herhangi bir sorgu, burada yardımcı olan başlıklar sağlar

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

Temelde koleksiyonları sorgulamak için nispeten doğrusal yükleme süresi ile genel bir sunucu olsun. Bu harika ve kendi uygulamanıza gitmek istiyorsanız bakmanız gereken bir şey.


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

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

    });
}

0

Bu basit eklentiyi kullanın.

https://github.com/WebGangster/mongoose-paginate-v2

Kurulum

npm install mongoose-paginate-v2
Kullanım Bir şemaya eklenti ekleyin ve sonra model paginate yöntemini kullanın:

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


Bu eklenti başka bir yanıtta "önerildi". Bu pakete katkıda bulunup bulunmadığınızı bilmek de yararlı olacaktır.
lukas_o

@lukas_o Evet. Eklentinin yaratıcısıyım.
Aravind NC

0

göre

Chris Hinkle

Cevap:

//assume every page has 50 result
const results = (req.query.page * 1) * 50;
MyModel.find( { fieldNumber: { $lte: results} })
.limit( 50 )
.sort( '+fieldNumber' )

//one thing left is create a fieldNumber on the schema thas holds ducument number

0

Ts-mongoose-pagination kullanma

    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)

0
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 > 0) {
   paginate.prev = {
       page: page - 1,
       limit: limit
} 
//For next page
 if(lastPage < counts) {
  paginate.next = {
     page: page + 1,
     limit: limit
}
results = await query //Here is the final results of the query.

-1

Async / await ile de sonuç elde edebildi.

Hapi v17 ve mongoose v5 ile bir zaman uyumsuz işleyici kullanarak aşağıdaki kod örneği

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

            }
        }
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.