নোড.জেজে মঙ্গুজের সাথে কীভাবে প্যাগিনেট করবেন?

Question

আমি নোড.জেএস এবং মঙ্গুজ দিয়ে একটি ওয়েব অ্যাপ লিখছি। আমি .find()কল থেকে প্রাপ্ত ফলাফলগুলিকে কীভাবে পৃষ্ঠাবদ্ধ করতে পারি ? আমি "LIMIT 50,100"এসকিউএল এর সাথে তুলনীয় একটি কার্যকারিতা চাই ।

Comments

সংগ্রহ থেকে ডেটা সন্ধান করার সময় স্কিপ এবং সীমাবদ্ধ সম্পত্তি ব্যবহার করুন।

— অরুণ সাহানী

এই লিঙ্কটি বিশদে আপনার জন্য ব্যবহৃত হতে পারে। laxmanchavda.blogspot.com/2018/06/...

— লক্ষ্মণ

Answer 1

আমি এই প্রশ্নের গৃহীত উত্তর দ্বারা খুব হতাশ। এটি স্কেল হবে না। আপনি যদি কার্সার.স্কিপ () তে সূক্ষ্ম মুদ্রণটি পড়েন:

কার্সার.স্কিপ () পদ্ধতিটি প্রায়শই ব্যয়বহুল কারণ ফলাফলটি ফেরার আগে অফসেট বা স্কিপ পজিশনটি সংগ্রহের জন্য সংগ্রহ বা সূচকের শুরু থেকে সার্ভারের প্রয়োজন হয়। অফসেট (উদাহরণস্বরূপ পৃষ্ঠা নম্বর) উপরে বাড়ার সাথে সাথে কার্সার.স্কিপ () ধীরে ধীরে এবং আরও সিপিইউ নিবিড় হয়ে উঠবে। বৃহত্তর সংগ্রহের সাথে কার্সার.স্কিপ () আইও আবদ্ধ হতে পারে।

কমপক্ষে একটি ফিল্টার মাপদণ্ডের সাথে একটি স্কেলযোগ্য উপায়ে পৃষ্ঠাগুলি অর্জনের জন্য একটি সীমাবদ্ধতা () একত্রিত করুন, তৈরির তারিখটি অনেকগুলি উদ্দেশ্য অনুসারে।

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

Comments

তবে কীভাবে আপনি এলোচনা ছাড়াই সেই প্রশ্নটি থেকে পৃষ্ঠাগুলি পাবেন? আপনি যদি প্রতি পৃষ্ঠায় 10 টি ফলাফল দেখছেন, এবং 100 টি ফলাফল রয়েছে, তবে আপনি কীভাবে অফসেট বা অগ্রাহ্য মানটি সংজ্ঞায়িত করবেন? আপনি পৃষ্ঠাগুলির প্রশ্নের উত্তর দিচ্ছেন না, সুতরাং আপনি 'হতাশ' হতে পারবেন না, যদিও এটি একটি বৈধ সাবধানতা। যদিও একই সমস্যাটি মাইএসকিউএল অফসেটে রয়েছে, সীমাবদ্ধ। ফলটি ফেরত দেওয়ার আগে গাছটিকে অফসেটে যেতে হবে। আমি এটির সাথে লবণের এক দানা দিয়ে নিয়ে যাব, যদি আপনার ফলাফলের সেটগুলি 1 মিলির চেয়ে কম হয় এবং সংরক্ষণযোগ্য পারফরম্যান্সের কোনও আঘাত হিট না হয়, এড়িয়ে যান ()।

— লেক্স

যখন আমি মঙ্গুজে / মঙ্গোদব এর কথা বলি তখন আমি নূব, তবে লেক্সের প্রশ্নের উত্তর দিতে গিয়ে মনে হয় যে ফলাফলগুলি ' -createdOn' দ্বারা অর্ডার করা হয় , আপনি আগের ফলাফলের সেটটিতে ফিরে request.createdOnBeforeআসা সর্বনিম্ন মানের সাথে প্রতিস্থাপন করবেন createdOn, এবং তারপর প্রয়োজনীয়।

— টেরি লুইস

@ জোফ্র্যামবাচ তৈরি করা ভিত্তিতে অনুরোধ করা সমস্যাযুক্ত বলে মনে হচ্ছে। স্কিপ একটি কারণে এম্বেড করা হয়েছে। ডক্সগুলি কেবল বিটি্রি সূচকের মাধ্যমে সাইক্লিংয়ের পারফরম্যান্স হিটের সতর্কতা দিচ্ছে, যা সমস্ত ডিবিএমএসের ক্ষেত্রে। ব্যবহারকারীদের জন্য "মাইএসকিউএল এর সাথে তুলনামূলক কিছু লিমিটেড 50,100 এর সাথে তুলনাযোগ্য" প্রশ্ন করা হয়েছে sk

— লেক্স

আকর্ষণীয় হলেও, এই উত্তরটির সাথে একটি সমস্যা, যেমন @ লিক্সের মন্তব্য নোটস, আপনি কেবল ফলাফলের মাধ্যমে "ফরোয়ার্ড" বা "পিছনে" এড়াতে পারবেন - আপনার "পৃষ্ঠা" থাকতে পারে না (যেমন পৃষ্ঠা 1, পৃষ্ঠা 2 , পৃষ্ঠা 3) পৃষ্ঠাগুলি কোথা থেকে শুরু করতে হবে তা নিয়ে কাজ করার জন্য একাধিক ক্রমিক প্রশ্ন তৈরি না করেই , যা আমি সন্দেহ করি যে কেবল বেশিরভাগ ক্ষেত্রে স্লিপ ব্যবহার না করেই বেশিরভাগ ক্ষেত্রে ধীর হতে চলেছে। অবশ্যই আপনার নির্দিষ্ট পৃষ্ঠাগুলি এড়িয়ে যাওয়ার ক্ষমতা যুক্ত করার প্রয়োজন নেই।

— আইয়েন কলিন্স

এই উত্তরে আকর্ষণীয় পয়েন্ট রয়েছে তবে এটি জিজ্ঞাসা করা মূল প্রশ্নের উত্তর দেয় না।

— স্টেপওয়ার্ড

Answer 2

রডল্ফের সরবরাহিত তথ্যের সাথে মঙ্গুজ এপিআইয়ের সন্ধানের পরে আমি এই সমাধানটি বের করেছিলাম:

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

Comments

"গণনা" সম্পর্কে কী? কত পৃষ্ঠাগুলি আছে তা আপনার জানতে হবে।

— আলেক্সে সাচ্চি

স্কেল করে না।

— ক্রিস হিঙ্কল

কেন এটি স্কেল হয় না ক্রিস হিঙ্কলের ব্যাখ্যা: stackoverflow.com/a/23640287/165330 ।

— imme

@ ক্রিসহিংল এটি সমস্ত ডিবিএমএস-এর ক্ষেত্রে বলে মনে হচ্ছে। সংযুক্ত উত্তরের নীচে লেক্সের মন্তব্য আরও ব্যাখ্যা বলে মনে হচ্ছে।

— সিএসটিরিউ

@ অভিজ হ্যাঁ আমি এর জন্য সনাক্তকারী ব্যবহার করেছি। আপনি সেখানে যা করেন তা হ'ল সর্বশেষ রেকর্ডস আইডিটি আবার সার্ভারে প্রেরণ করা হয় এবং প্রেরণের চেয়ে আইডি সহ কিছু রেকর্ড পান। আইডিকে যেমন সূচিত করা হয়, তত দ্রুত হবে

— জর্জ বেইলি

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

আপনার উত্তরের জন্য আপনাকে ধন্যবাদ, ফলাফলের সাথে কলব্যাক কীভাবে এতে যুক্ত হল?

— থমাস

এক্সকিউফাইন্ড (ফাংশন (... উদাহরণস্বরূপ: 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 }); }); });

— টুড

নোট: এই কাজ করবে না নকুল , কিন্তু এটা MongoDB-দেশীয়-চালক কাজ করবে।

— জেসি

Answer 5

এই ক্ষেত্রে, আপনি ক্যোয়ারী স্ট্রিং হিসাবে ক্যোয়ারী pageএবং / অথবা limitআপনার URL এ যুক্ত করতে পারেন ।

উদাহরণ স্বরূপ:
?page=0&limit=25 // this would be added onto your URL: http:localhost:5000?page=0&limit=25

যেহেতু এটি আমাদের গণনার জন্য Stringএকে রূপান্তর করা দরকার a 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);
    });

বিটিডাব্লু প্যাজিনেশন দিয়ে শুরু হয়0

Comments

দয়া করে `{পৃষ্ঠা যুক্ত করুন: পার্সেন্ট (req.query.page) || 0, ... the প্যারামিটারে।

— imalik8088

@ ইমামালিক 8088 আপনাকে ধন্যবাদ, তবে আফাইক স্ট্রিং প্যারামগুলি স্বয়ংক্রিয়ভাবে পরিচালিত হচ্ছে mongoose।

— CENT1PEDE

আচরণটি প্রত্যাশা করছিল কিন্তু আমার ক্ষেত্রে এটি গোপন করতে এবং আমাকে ত্রুটি

— দেখাতে পারেনি

@ imalik8088 এটি অদ্ভুত। আপনি যদি কোনও পুনরুত্পাদন ত্রুটি দেখাতে পারতেন তবে আমি আমার উত্তরটি সম্পাদনা করতে পারি। ধন্যবাদ।

— CENT1PEDE

এটি কি শর্ত প্রয়োগের আগে মঙ্গুজকে প্রতিটি রেকর্ড খুঁজে পেতে পারে?

— ফ্লফিবেইং

Answer 6

আপনি মঙ্গুজ প্যাগিনেট নামক একটি সামান্য প্যাকেজ ব্যবহার করতে পারেন যা এটি আরও সহজ করে তোলে।

$ 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 গণনা পেতে এবং সীমা এটি দ্বারা বিভক্ত

— edthethird

count()অবচয় করা হয়। ব্যবহারcountDocuments()

— Ruslan

Answer 10

প্রশ্ন;
অনুসন্ধান = productName,

প্যারাম;
পৃষ্ঠা = 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

এই উত্তরের জন্য ধন্যবাদ; আমি থ্রেডটি পড়ে প্রথমে চেষ্টা করেছি কারণ এটি ছিল সাম্প্রতিকতম একটি। যাইহোক, যখন আমি এটি বাস্তবায়ন করেছি তখন আমি একটি বাগ আবিষ্কার করেছি - যেমনটি এখন লেখা আছে এটি ফলাফলের প্রথম পৃষ্ঠাটি কখনই ফিরিয়ে আনবে না, কারণ এটির সর্বদা এড়িয়ে যাওয়ার মান থাকবে। প্রোডাক্ট.ফাইন্ড () কল করার আগে "পৃষ্ঠা = পৃষ্ঠা -1" যুক্ত করার চেষ্টা করুন।

— আন্তঃসংযোগ

Answer 11

এখানে এমন একটি সংস্করণ রয়েছে যা আমি আমার সমস্ত মডেলের সাথে সংযুক্ত করি। এটি সুবিধার জন্য আন্ডারস্কোর এবং পারফরম্যান্সের জন্য অ্যাসিঙ্কের উপর নির্ভর করে। অপ্টগুলি মঙ্গুজ সিনট্যাক্স ব্যবহার করে ক্ষেত্র নির্বাচন এবং বাছাইয়ের অনুমতি দেয়।

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

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

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

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

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

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

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

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

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

  return qry;
}

এটি আপনার মডেল স্কিমাতে সংযুক্ত করুন।

MySchema.statics.findPaginated = findPaginated;

Answer 12

উত্তরের উত্তর ভাল আছে।

যে প্রতিশ্রুতি না দিয়ে async- এ অপেক্ষা করছে কেবল তার জন্য কেবল একটি অ্যাড-অন !!

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 ইত্যাদি etc.

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

এটি বাস্তবায়নের জন্য একটি দৃ approach় দৃষ্টিভঙ্গি হ'ল একটি ক্যোরি স্ট্রিং ব্যবহার করে সীমান্ত থেকে মানগুলি পাস করা । ধরা যাক আমরা পৃষ্ঠা 2 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:""};

প্রতিক্রিয়া ডেটা থেকে প্রথম এবং শেষ অবজেক্টআইডি নিন

পৃষ্ঠা পরবর্তী শর্ত

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

সীমাবদ্ধ সংগ্রহ বা নথিগুলির মধ্যে স্কিপ এবং সীমাবদ্ধ করা বাটকে সীমাবদ্ধ করা সর্বোত্তম পন্থা (আইএমও)।

সীমাবদ্ধ নথিগুলির মধ্যে ক্যোয়ারী তৈরি করতে, আমরা নির্দিষ্ট তারিখের মতো সূচী যেমন 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

এই প্লাগইনটি মঙ্গুজ ভি 5.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);
        }
    });

পৃষ্ঠা: অনুরোধ পরামিতি হিসাবে ক্লায়েন্ট থেকে পৃষ্ঠা নম্বর আসছে।
প্রতি_পৃষ্ঠা: প্রতি পৃষ্ঠায় প্রদর্শিত ফলাফলের কোনও নয়

আপনি যদি এমইএন স্ট্যাক ব্যবহার করছেন তবে নিম্নলিখিত ব্লগ পোস্টটি কৌণিক-ইউআই বুটস্ট্র্যাপ ব্যবহার করে এবং ব্যাকএন্ডে মঙ্গুজ স্কিপ এবং সীমাবদ্ধকরণ পদ্ধতি ব্যবহার করে সামনের প্রান্তে পৃষ্ঠা তৈরির জন্য প্রচুর তথ্য সরবরাহ করে।

দেখুন: https://techpituwa.wordpress.com/2015/06/06/mean-js-pagination-with-angular-ui-bootstrap/

Answer 21

আপনি হয় স্কিপ () এবং সীমা () ব্যবহার করতে পারেন তবে এটি খুব অকার্যকর। আরও ভাল সমাধান ইনডেক্সেড ফিল্ড প্লাস সীমা () এর ক্ষেত্রে বাছাই করা হবে। আমরা ওয়ান্ডারফ্লাটস-এ এখানে একটি ছোট্ট lib প্রকাশ করেছি: https://github.com/wunderflats/goosepage এটি প্রথম উপায়ে ব্যবহার করে।

Answer 22

আপনি যদি বিশ্রামের এপিআইর জন্য উত্স হিসাবে মঙ্গুজ ব্যবহার করছেন তবে ' পুনরায় সংশোধন-মঙ্গুজ ' এবং এর প্রশ্নগুলি দেখুন at এটি হ'ল এই কার্যকারিতাটি অন্তর্নির্মিত।

কোনও সংগ্রহে থাকা যে কোনও ক্যোয়ারী এখানে সহায়ক এমন শিরোনাম সরবরাহ করে

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

@ লুকাস_ও হ্যাঁ আমি প্লাগইনটির স্রষ্টা।

— অরবিন্দ এনসি

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

টিএস-মঙ্গুজ-পৃষ্ঠাগুলি ব্যবহার করে

    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 / ফলাফল হিসাবেও ফলাফল অর্জন করতে সক্ষম হয়েছিল।

হাইপি ভি 17 এবং মঙ্গুজ ভি 5 সহ অ্যাসিঙ্ক হ্যান্ডলারটি ব্যবহার করে নীচের কোডের উদাহরণ

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

            }
        }