Node.js में Mongoose के साथ कैसे पैगिनेट करें?

Question

मैं Node.js और mongoose के साथ एक वेबपेज लिख रहा हूं। मैं .find()कॉल से प्राप्त होने वाले परिणामों को कैसे शांत कर सकता हूं ? मैं "LIMIT 50,100"एसक्यूएल में तुलनीय कार्यक्षमता चाहता हूं ।

Comments

संग्रह से डेटा प्राप्त करते समय स्किप और सीमित संपत्ति का उपयोग करें।

— अरुण सहनी

इस लिंक का उपयोग आपके लिए विवरण में किया जा सकता है। laxmanchavda.blogspot.com/2018/06/...

— लक्ष्मण

Answer 1

मैं इस प्रश्न में स्वीकृत उत्तरों से बहुत निराश हूँ। यह पैमाना नहीं होगा। यदि आप कर्सर पर बढ़िया प्रिंट पढ़ते हैं ।स्काइप ():

कर्सर.स्किप () विधि अक्सर महंगी होती है क्योंकि इसमें सर्वर को संग्रह या सूचकांक की शुरुआत से चलने की आवश्यकता होती है ताकि परिणाम प्राप्त करने से पहले ऑफसेट या स्किप की स्थिति प्राप्त की जा सके। जैसे ही ऑफसेट (उदाहरण के लिए पेजनंबर ऊपर) बढ़ता है, कर्सर.स्किप () धीमा और अधिक सीपीयू गहन हो जाएगा। बड़े संग्रह के साथ, कर्सर.स्किप () IO बाध्य हो सकता है।

स्केलेबल तरीके से पृष्ठांकन प्राप्त करने के लिए कम से कम एक फिल्टर मानदंड के साथ एक सीमा () को मिलाएं, एक निर्मित डेट कई उद्देश्यों के लिए उपयुक्त है।

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

Comments

लेकिन आप उस पृष्ठ से दो पृष्ठ कैसे छोड़ेंगे? यदि आप प्रति पृष्ठ 10 परिणाम देख रहे हैं, और 100 परिणाम हैं, तो आप ऑफसेट या स्किप मूल्य को कैसे परिभाषित करते हैं? आप पेजिंग के सवाल का जवाब नहीं दे रहे हैं, इसलिए आप 'निराश' नहीं हो सकते, हालांकि यह एक वैध सावधानी है। यद्यपि MySQL ऑफसेट में एक ही मुद्दा है, सीमा। परिणाम लौटाने से पहले पेड़ को ऑफसेट तक पहुंचाना होता है। मैं इसे नमक के एक दाने के साथ ले जाऊंगा, यदि आपके परिणाम सेट 1mil से कम हैं और कोई प्रिजर्वेबल प्रदर्शन हिट नहीं है, तो स्किप () का उपयोग करें।

— लेक्स

मैं एक नॉब हूँ जब यह मानस / मोंगोडब की बात आती है, लेकिन लेक्स के सवाल का जवाब देने के लिए, ऐसा प्रतीत होता है कि, जैसा कि परिणाम ' -createdOn' द्वारा आदेश दिया गया है , आप पिछले परिणाम सेट में दिए गए request.createdOnBeforeकम से कम मूल्य के साथ मूल्य को बदल देंगे createdOn। और फिर आवश्यकता है।

— टेरी लुईस

@JoeFrambach बनाया गया आधार पर अनुरोध समस्याग्रस्त लगता है। स्किप को एक कारण के लिए एम्बेड किया गया था। डॉक्स केवल btree इंडेक्स के माध्यम से साइकिल के प्रदर्शन हिट की चेतावनी है, जो सभी DBMS के साथ होता है। उपयोगकर्ताओं के लिए "कुछ तुलना करने योग्य MySQL 50,100 लिमिट करने के लिए प्रश्न" .skip बिल्कुल सही है।

— लेक्स

जबकि दिलचस्प है, इस उत्तर के साथ एक समस्या, @Lex टिप्पणी नोटों के रूप में, यह है कि आप केवल "फॉरवर्ड" या "बैक" को परिणामों के माध्यम से छोड़ सकते हैं - आपके पास "पेज" नहीं हो सकते हैं (जैसे पेज 1, पेज 2) पेज 3) कई अनुक्रमिक प्रश्न किए बिना कि काम शुरू करने के लिए कहां से शुरू करें, जिस पर मुझे संदेह है कि ज्यादातर मामलों में धीमी गति से उपयोग करने की तुलना में धीमा होने जा रहा है। बेशक आपको विशिष्ट पृष्ठों को छोड़ने की क्षमता जोड़ने की आवश्यकता नहीं हो सकती है।

— इयान कॉलिन्स

इस उत्तर में दिलचस्प बिंदु हैं, लेकिन यह पूछे गए मूल प्रश्न का उत्तर नहीं देता है।

— स्टीमपॉवर ने

Answer 2

रोडोलपे द्वारा दी गई जानकारी के साथ मोंगोज एपीआई पर करीब से नज़र डालने के बाद, मैंने इस समाधान का पता लगाया:

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

Comments

"गिनती" के बारे में क्या? आपको यह जानने की आवश्यकता है कि कितने पृष्ठ हैं।

— अलेक्सी साची

पैमाना नहीं है।

— क्रिस हिंकले

क्रिस हिंकल की व्याख्या क्यों यह पैमाने नहीं है: stackoverflow.com/a/23640287/165330 ।

— imme

@ क्रिसहिंक सभी डीबीएमएस के साथ ऐसा लगता है। लिंक्ड जवाब के नीचे लेक्स की टिप्पणी अधिक व्याख्या करती प्रतीत होती है।

— csotiriou

@ आविज हाँ। मैंने इसके लिए पहचानकर्ता का उपयोग किया है। आप वहां क्या करते हैं पिछले रिकॉर्ड आईडी को सर्वर पर भेजते हैं और भेजे गए आईडी से कुछ रिकॉर्ड प्राप्त करते हैं। जैसा कि आईडी को अनुक्रमित किया गया है, यह बहुत तेज़ होगा

— जॉर्ज बेली

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

Comments

अपना उत्तर पोस्ट करने के लिए धन्यवाद! कृपया सेल्फ-प्रमोशन पर अक्सर पूछे जाने वाले प्रश्नों को ध्यान से पढ़ें । यह भी ध्यान दें कि यह आवश्यक है कि आप हर बार जब आप अपनी साइट / उत्पाद से लिंक करते हैं तो एक अस्वीकरण पोस्ट करें।

— एंड्रयू नाई

Math.max(0, undefined)लौटेंगे undefined, इसने मेरे लिए काम किया: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

Answer 4

आप इस तरह से चेन कर सकते हैं:

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

क्वेरी का उपयोग करके निष्पादित करें exec

query.exec(callback);

Comments

आपके उत्तर के लिए धन्यवाद, इस परिणाम के साथ कॉलबैक कैसे जोड़ा जाता है?

— थॉमस

execFind (समारोह (... उदाहरण के लिए: 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 }); }); });

— टोड

नोट: यह मोंगोज़ में काम नहीं करेगा , लेकिन यह मोंगोडब-मूल-चालक में काम करेगा।

— जेसी

Answer 5

इस स्थिति में, आप एक क्वेरी स्ट्रिंग के रूप में अपने URL में क्वेरी pageऔर / या जोड़ सकते हैं limit।

उदाहरण के लिए:
?page=0&limit=25 // this would be added onto your URL: http:localhost:5000?page=0&limit=25

चूंकि यह हमारी गणना के लिए Stringइसे परिवर्तित करने की आवश्यकता होगी Number। चलो इसे parseIntविधि का उपयोग करते हैं और चलो कुछ डिफ़ॉल्ट मान भी प्रदान करते हैं।

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 पेजिनेशन के साथ शुरू होता है0

Comments

कृपया `{पृष्ठ जोड़ें: parseInt (req.query.page) || 0, ...} पैरामीटर के लिए।

— imalik8088

@ imalik8088 धन्यवाद, हालांकि AFAIK स्ट्रिंग परम को स्वचालित रूप से नियंत्रित किया जा रहा है mongoose।

— CENT1PEDE 8

व्यवहार की उम्मीद कर रहा था लेकिन मेरे मामले में यह गुप्त नहीं हो सकता था और मुझे त्रुटि दिखा रहा था

— imalik8088

@ imalik8088 यह अजीब है। शायद अगर आप एक प्रजनन त्रुटि दिखा सकते हैं तो मैं अपना उत्तर संपादित कर सकता हूं। धन्यवाद।

— CENT1PEDE

क्या यह शर्तों को लागू करने से पहले हर रिकॉर्ड को खोजने के लिए आम का कारण होगा?

— 22

Answer 6

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

Comments

क्या यह अनुकूलित है?

— अर्जेंटीना

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

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

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

मैंने ऐसा ही किया है।

Comments

पृष्ठों की कुल संख्या कैसे प्राप्त करें

— Rhushikesh

हाय @ ऋषिकेश, आप गिनती प्राप्त करने के लिए एक गिनती () फ़ंक्शन का उपयोग कर सकते हैं। लेकिन ऐसा लगता है कि डेटाबेस से एक और क्वेरी की आवश्यकता है। यहाँ विवरण mongoosejs.com/docs/api.html#model_Model.count

— इंद्र संतो

@ ऋषिकेश को गिनती मिलती है और इसे सीमा से विभाजित करते हैं

— edthethird

count()पदावनत किया गया है। उपयोगcountDocuments()

— रुस्लान

Answer 10

क्वेरी;
खोज = उत्पादनाम,

पैरामीटर;
पेज = 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);
    });
});

Comments

इस उत्तर के लिए धन्यवाद; मैंने इसे पहले थ्रेड के माध्यम से पढ़ने के बाद आजमाया क्योंकि यह हाल के दिनों में से एक था। हालाँकि, जब मैंने इसे लागू किया, तो मुझे एक बग का पता चला - जैसा कि अब लिखा गया है, यह परिणामों के पहले पृष्ठ को कभी नहीं लौटाएगा, क्योंकि यह हमेशा एक मूल्य छोड़ देगा। Product.find () कॉल से पहले "पृष्ठ = पृष्ठ -1" जोड़ने का प्रयास करें।

— इंटर जॉग

Answer 11

यहां एक संस्करण है जिसे मैं अपने सभी मॉडलों से जोड़ता हूं। यह प्रदर्शन के लिए सुविधा और async के लिए अंडरस्कोर पर निर्भर करता है। ऑप्स मैंगोज़ सिंटैक्स का उपयोग करके फ़ील्ड चयन और सॉर्टिंग के लिए अनुमति देता है।

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;

Answer 12

ऊपर से उत्तर की पकड़ अच्छी है।

वादा करने के बजाए जो कोई भी async-wait में है उसके लिए बस एक ऐड !!

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

Answer 13

सरल और शक्तिशाली पेजिनेशन समाधान

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: अंतिम दस्तावेज़ आईडी जो आपको मिलती है

no_of_docs_required: डॉक्स की संख्या जो आप लाना चाहते हैं अर्थात 5, 10, 50 आदि।

1. यदि आप प्रदान नहीं करते हैं last_doc_id विधि , तो आपको 5 नवीनतम डॉक्स मिलेंगे
2. यदि आपने प्रदान किया है last_doc_idतो आपको अगले यानी 5 दस्तावेज़ मिलेंगे।

Answer 14

आप कोड की निम्न पंक्ति का भी उपयोग कर सकते हैं

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

यह कोड मोंगो के नवीनतम संस्करण में काम करेगा

Answer 15

इसे लागू करने के लिए एक ठोस दृष्टिकोण क्वेरी स्ट्रिंग का उपयोग करके सीमा से मूल्यों को पारित करना होगा । मान लें कि हम पृष्ठ # 2 प्राप्त करना चाहते हैं और आउटपुट को 25 परिणामों तक सीमित करना चाहते हैं । क्वेरी स्ट्रिंग इस तरह दिखेगा:
?page=2&limit=25 // this would be added onto your URL: http:localhost:5000?page=2&limit=25

आइए देखें कोड:

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

---

मैं इस तर्क को मिडलवेयर में लागू करने का सुझाव दूंगा ताकि आप इसे विभिन्न मार्गों / नियंत्रकों के लिए उपयोग करने में सक्षम हो सकें।

Answer 16

सबसे आसान और अधिक तेज़ तरीका है, ऑब्जेक्टआईड उदाहरण के साथ पेजेट;

प्रारंभिक लोड की स्थिति

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

Answer 17

सबसे अच्छा दृष्टिकोण (IMO) एक सीमित संग्रह या दस्तावेजों के भीतर BUT को छोड़ना और सीमित करना है।

सीमित दस्तावेज़ों के भीतर क्वेरी बनाने के लिए, हम विशिष्ट प्रकार जैसे सूचकांक का उपयोग 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)

Answer 18

पेजिंग के लिए सबसे आसान प्लगइन।

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

एक स्कीमा में प्लगइन जोड़ें और फिर मॉडल पेजेंट विधि का उपयोग करें:

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

Comments

इस प्लगइन mongoose v5.5.5 के साथ टूट गया है

— इसहाक पाक

Answer 19

यह पेजिंग और सीमा विकल्पों के साथ कौशल मॉडल का परिणाम प्राप्त करने के लिए उदाहरण फ़ंक्शन है

 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

}

Answer 20

आप इस तरह क्वेरी लिख सकते हैं।

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 स्टैक का उपयोग कर रहे हैं, तो कोणीय-यूआई बूटस्ट्रैप का उपयोग करके फ्रंट में पेजेशन बनाने और बैकएंड में विधियों को सीमित करने के लिए बहुत सी जानकारी प्रदान करता है।

देखें: https://techpituwa.wordpress.com/2015/06/06/mean-js-pagination-with-angular-ui-bootstrap/

Answer 21

आप या तो स्किप () और सीमा () का उपयोग कर सकते हैं, लेकिन यह बहुत अक्षम है। एक बेहतर समाधान अनुक्रमित क्षेत्र प्लस सीमा () पर एक प्रकार होगा। Wunderflats में हमने एक छोटा सा काम यहां प्रकाशित किया है: https://github.com/wunderflats/goosepage यह पहले तरीके का उपयोग करता है।

Answer 22

यदि आप एक सामान्य एपी के लिए एक स्रोत के रूप में मानगो का उपयोग कर रहे हैं तो ' पुनर्स्थापना-मोंगोज ' और इसके प्रश्नों पर एक नज़र डालें । यह बिल्कुल इस कार्यक्षमता में निर्मित है।

एक संग्रह पर कोई भी क्वेरी हेडर प्रदान करती है जो यहां सहायक हैं

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

तो मूल रूप से आपको प्रश्नों के संग्रह के लिए अपेक्षाकृत रैखिक लोड समय के साथ एक सामान्य सर्वर मिलता है। यह कमाल है और अगर आप खुद के कार्यान्वयन में जाना चाहते हैं तो कुछ देखना है।

Answer 23

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

Answer 24

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

    });
}

Answer 25

इस सरल प्लगइन का उपयोग करें।

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

स्थापना

npm install mongoose-paginate-v2

स्कीमा में प्लगइन जोड़ें और फिर मॉडल पेजेंट विधि का उपयोग करें:

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

Comments

यह प्लगइन पहले से ही एक और जवाब में "सुझाया गया" है। यह जानना भी उपयोगी होगा कि आप इस पैकेज में योगदानकर्ता हैं या नहीं।

— lukas_o

@lukas_o हां। मैं प्लगइन का निर्माता हूँ।

— अरविंद

Answer 26

इसके अनुसार

क्रिस हिंकल

का जवाब:

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

Answer 27

Ts-mongoose-pagination का उपयोग करना

    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)

Answer 28

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.

Answer 29

के रूप में अच्छी तरह से async / प्रतीक्षा के साथ परिणाम प्राप्त करने में सक्षम था।

कोड उदाहरण नीचे hapi v17 और mongoose v5 के साथ एक async हैंडलर का उपयोग कर रहा है

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

            }
        }