Wie paginiere ich mit Mongoose in Node.js?

231

Ich schreibe eine Webapp mit Node.js und Mungo. Wie kann ich die Ergebnisse eines .find()Anrufs paginieren ? Ich möchte eine Funktionalität, die mit "LIMIT 50,100"SQL vergleichbar ist .

Thomas
quelle
Verwenden Sie die Eigenschaft skip and limit, während Sie Daten aus der Sammlung suchen.
Arun Sahani
Dieser Link kann für Sie im Detail verwendet werden. laxmanchavda.blogspot.com/2018/06/…
laxman

Antworten:

278

Ich bin sehr enttäuscht von den akzeptierten Antworten in dieser Frage. Dies wird nicht skaliert. Wenn Sie das Kleingedruckte auf cursor.skip () lesen:

Die Methode cursor.skip () ist häufig teuer, da der Server vom Anfang der Sammlung oder des Index gehen muss, um die Offset- oder Sprungposition abzurufen, bevor das Ergebnis zurückgegeben wird. Mit zunehmendem Offset (z. B. Seitennummer oben) wird cursor.skip () langsamer und CPU-intensiver. Bei größeren Sammlungen kann cursor.skip () an die E / A gebunden werden.

Um eine skalierbare Paginierung zu erreichen, kombinieren Sie ein Limit () mit mindestens einem Filterkriterium. Ein Erstellungsdatum eignet sich für viele Zwecke.

MyModel.find( { createdOn: { $lte: request.createdOnBefore } } )
.limit( 10 )
.sort( '-createdOn' )
Chris Hinkle
quelle
105
Aber wie würden Sie Seite zwei aus dieser Abfrage erhalten, ohne zu überspringen? Wenn Sie 10 Ergebnisse pro Seite anzeigen und 100 Ergebnisse vorliegen, wie definieren Sie dann den Versatz oder den Sprungwert? Sie beantworten die Frage der Paginierung nicht, können also nicht "enttäuscht" werden, obwohl dies eine berechtigte Warnung ist. Obwohl das gleiche Problem beim MySQL-Offset auftritt, beschränken Sie sich. Es muss den Baum bis zum Versatz durchlaufen, bevor Ergebnisse zurückgegeben werden. Ich würde dies mit einem Körnchen Salz nehmen. Wenn Ihre Ergebnismengen weniger als 1 mil betragen und es keinen konservierbaren Leistungstreffer gibt, verwenden Sie skip ().
Lex
13
Ich bin ein Neuling, wenn es um Mungo / Mongodb geht, aber um Lex 'Frage zu beantworten, scheint es , dass Sie, da die Ergebnisse nach' -createdOn' geordnet sind , den Wert von request.createdOnBeforedurch den niedrigsten Wert von createdOnin der vorherigen Ergebnismenge ersetzen würden. und dann Requery.
Terry Lewis
9
@JoeFrambach Das Anfordern basierend auf createdOn scheint problematisch. Skip wurde aus einem bestimmten Grund eingebettet. Die Dokumente warnen nur vor dem Leistungseinbruch beim Durchlaufen des btree-Index, was bei allen DBMS der Fall ist. Für die Benutzerfrage "etwas vergleichbares MySQL mit LIMIT 50.100" ist .skip genau richtig.
Lex
8
Ein interessantes Problem bei dieser Antwort ist, wie @Lex-Kommentar feststellt, dass Sie nur "vorwärts" oder "zurück" durch die Ergebnisse springen können - Sie können keine "Seiten" haben, zu denen Sie springen können (z. B. Seite 1, Seite 2) , Seite 3) ohne mehrere aufeinanderfolgende Abfragen durchzuführen, um herauszufinden, wo die Paginierung beginnen soll. Ich vermute, dass dies in den meisten Fällen langsamer sein wird als nur die Verwendung von Überspringen. Natürlich müssen Sie möglicherweise nicht die Möglichkeit hinzufügen, zu bestimmten Seiten zu springen.
Iain Collins
20
Diese Antwort enthält interessante Punkte, beantwortet jedoch nicht die ursprünglich gestellte Frage.
Steampowered
226

Nachdem ich mir die Mongoose-API mit den von Rodolphe bereitgestellten Informationen genauer angesehen hatte, fand ich diese Lösung heraus:

MyModel.find(query, fields, { skip: 10, limit: 5 }, function(err, results) { ... });
Thomas
quelle
21
Was ist mit "zählen"? Sie benötigen das, um zu wissen, wie viele Seiten es gibt.
Aleksey Saatchi
36
Skaliert nicht.
Chris Hinkle
4
Chris Hinkles Erklärung, warum dies nicht skaliert: stackoverflow.com/a/23640287/165330 .
Imme
7
@ChrisHinkle Dies scheint bei allen DBMS der Fall zu sein. Lex 'Kommentar unter der verknüpften Antwort scheint mehr zu erklären.
Csotiriou
2
@ Avij ja. Ich habe dafür einen Bezeichner verwendet. Dort senden Sie die ID der letzten Datensätze an den Server zurück und erhalten einige Datensätze mit einer ID, die größer als die gesendete ist. Da Id so indiziert ist, wird es viel schneller sein
George Bailey
107

Paginierung mit Mungo, Express und Jade - Hier ist ein Link zu meinem Blog mit mehr Details

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
            })
        })
    })
Madhusudhan
quelle
26
Vielen Dank für Ihre Antwort! Bitte lesen Sie die FAQ zur Eigenwerbung sorgfältig durch. Beachten Sie auch , dass Sie jedes Mal, wenn Sie auf Ihre eigene Website / Ihr eigenes Produkt verlinken, einen Haftungsausschluss veröffentlichen müssen.
Andrew Barber
Math.max(0, undefined)wird zurückkehren undefined, das hat bei mir funktioniert: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

Sie können einfach so verketten:

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

Führen Sie die Abfrage mit aus exec

query.exec(callback);
Rodolphe
quelle
Vielen Dank für Ihre Antwort. Wie wird der Rückruf mit dem Ergebnis hinzugefügt?
Thomas
2
execFind (Funktion (... zum Beispiel: 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
Hinweis: Dies funktioniert nicht bei Mungos , aber bei Mongodb-Native-Treibern.
Jesse
39

In diesem Fall können Sie die Abfrage pageund / oder limitIhre URL als Abfragezeichenfolge hinzufügen .

Beispielsweise:
?page=0&limit=25 // this would be added onto your URL: http:localhost:5000?page=0&limit=25

Da es ein wäre, müssen Stringwir es Numberfür unsere Berechnungen in ein konvertieren . Machen wir es mit der parseIntMethode und geben wir auch einige Standardwerte an.

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 Paginierung beginnt mit0

CENT1PEDE
quelle
5
Bitte fügen Sie die `{page: parseInt (req.query.page) || hinzu 0, ...} zum Parameter.
imalik8088
@ imalik8088 Vielen Dank, aber AFAIK-String-Parameter werden automatisch von verarbeitet mongoose.
CENT1PEDE
1
Ich habe das Verhalten erwartet, aber in meinem Fall konnte es nicht verdeckt werden und zeigte mir einen Fehler
imalik8088
@ imalik8088 Das ist komisch. Wenn Sie einen Reproduktionsfehler anzeigen könnten, könnte ich meine Antwort möglicherweise bearbeiten. Vielen Dank.
CENT1PEDE
2
Würde dies dazu führen, dass Mungo jeden Datensatz findet, bevor die Bedingungen angewendet werden?
FluffyBeing
37

Sie können ein kleines Paket namens Mongoose Paginate verwenden , das es einfacher macht.

$ npm install mongoose-paginate

Fügen Sie nach Ihren Routen oder Ihrem Controller einfach Folgendes hinzu:

/**
 * 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);
  }
}
Clément Renaud
quelle
2
Ist das optimiert?
Argento
16

Dies ist ein Beispielbeispiel, das Sie ausprobieren können.

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
      });
  });
 });
Libu Mathew
quelle
11

Versuchen Sie, die Mungofunktion für die Paginierung zu verwenden. Limit ist die Anzahl der Datensätze pro Seite und die Anzahl der Seiten.

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

Das habe ich mit Code gemacht

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

So habe ich es gemacht.

Indra Santosa
quelle
1
Wie bekomme ich die Gesamtzahl der Seiten
Rhushikesh
Hallo @ Rhushikesh, Sie können eine count () -Funktion verwenden, um die Zählung zu erhalten. Es scheint jedoch eine andere Abfrage aus der Datenbank zu sein. Details hier mongoosejs.com/docs/api.html#model_Model.count
Indra Santosa
@ Rhushikesh erhalten Sie die Zählung und teilen Sie es durch das Limit
edthethird
count()ist veraltet. Verwenden SiecountDocuments()
Ruslan
7

Abfrage;
search = productName,

Params;
Seite = 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);
    });
});
Jacob Benaim
quelle
Danke für diese Antwort; Ich habe es zuerst versucht, nachdem ich den Thread gelesen hatte, weil es einer der neueren war. Als ich es implementierte, entdeckte ich jedoch einen Fehler - so wie er jetzt geschrieben ist, wird er niemals die erste Ergebnisseite zurückgeben, da er IMMER einen Sprungwert hat. Fügen Sie vor dem Aufruf von Product.find () "page = page-1" hinzu.
Interog vor
6

Hier ist eine Version, die ich an alle meine Modelle anhänge. Dies hängt vom Unterstrich ab und ist für die Leistung asynchron. Die Optionen ermöglichen die Auswahl und Sortierung von Feldern mithilfe der Mungosyntax.

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

Hängen Sie es an Ihr Modellschema an.

MySchema.statics.findPaginated = findPaginated;
kberg
quelle
5

Die obige Antwort gilt.

Nur ein Add-On für alle, die eher auf Async-Warten als auf Versprechen stehen !!

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
        });
    }
};
Sabunkar Tejas Sahailesh
quelle
5

Einfache und leistungsstarke Paginierungslösung

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: Die letzte Dokument-ID, die Sie erhalten

no_of_docs_required: Die Anzahl der Dokumente, die Sie abrufen möchten, z. B. 5, 10, 50 usw.

  1. Wenn Sie last_doc_iddie Methode nicht angeben , erhalten Sie dh 5 neueste Dokumente
  2. Wenn Sie das bereitgestellt haben, erhalten last_doc_idSie die nächsten, dh 5 Dokumente.
WasiF
quelle
4

Sie können auch die folgende Codezeile verwenden

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

Dieser Code funktioniert in der neuesten Version von Mongo

Apoorv
quelle
3

Ein solider Ansatz, um dies zu implementieren, besteht darin, die Werte vom Frontend mithilfe einer Abfragezeichenfolge zu übergeben . Lassen Sie uns sagen , dass wir erhalten möchten Seite # 2 und auch begrenzen die Ausgabe auf 25 Ergebnisse .
Die Abfragezeichenfolge würde folgendermaßen aussehen:?page=2&limit=25 // this would be added onto your URL: http:localhost:5000?page=2&limit=25

Sehen wir uns den Code an:

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

Ich würde vorschlagen, diese Logik in Middleware zu implementieren, damit Sie sie für verschiedene Routen / Controller verwenden können.

Dzenis H.
quelle
2

Der einfachste und schnellere Weg ist, mit dem objectId-Beispiel zu paginieren.

Anfangslastzustand

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

Nehmen Sie die erste und letzte ObjectId aus den Antwortdaten

Seite nächste Bedingung

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

Seite nächste Bedingung

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

Im Mungo

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);
});
byteC0de
quelle
2

Der beste Ansatz (IMO) ist das Überspringen und Begrenzen von ABER innerhalb begrenzter Sammlungen oder Dokumente.

Um die Abfrage in begrenzten Dokumenten durchzuführen, können wir einen bestimmten Index wie einen Index für ein Feld vom Typ DATE verwenden. Siehe das unten

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)
Nazmul Hassan
quelle
2

Einfachstes Plugin für die Paginierung.

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

Fügen Sie einem Schema ein Plugin hinzu und verwenden Sie dann die Modell-Paginate-Methode:

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
Arv Ot
quelle
Dieses Plugin ist mit Mungo v5.5.5
Isaac Pak
1

Dies ist eine Beispielfunktion, um das Ergebnis eines Skills-Modells mit Paginierungs- und Limit-Optionen zu erhalten

 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

}}

Venkatesh Somu
quelle
0

Sie können eine solche Abfrage schreiben.

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

Seite: Seitennummer vom Client als Anforderungsparameter.
per_page: Anzahl der pro Seite angezeigten Ergebnisse

Wenn Sie den MEAN-Stack verwenden, enthält der folgende Blog-Beitrag viele Informationen zum Erstellen einer Paginierung im Front-End mithilfe des Bootstraps mit eckiger Benutzeroberfläche und der Verwendung von Mungo-Skip- und Limit-Methoden im Backend.

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

Manoj Sanjeewa
quelle
0

Sie können entweder skip () und limit () verwenden, aber es ist sehr ineffizient. Eine bessere Lösung wäre eine Sortierung nach indiziertem Feld plus limit (). Wir bei Wunderflats haben hier eine kleine Bibliothek veröffentlicht: https://github.com/wunderflats/goosepage Es verwendet den ersten Weg.

Jan Hase
quelle
0

Wenn Sie Mungo als Quelle für eine erholsame API verwenden, schauen Sie sich ' restify-mongoose ' an ' und seine Abfragen an. Es hat genau diese Funktionalität eingebaut.

Jede Abfrage in einer Sammlung enthält Header, die hier hilfreich sind

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

Grundsätzlich erhalten Sie also einen generischen Server mit einer relativ linearen Ladezeit für Abfragen an Sammlungen. Das ist großartig und etwas zu sehen, wenn Sie in eine eigene Implementierung gehen möchten.

Sebastian Schürmann
quelle
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});
            }
        });
});
jvitoroc
quelle
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);
            });

    });
}
Chetan
quelle
0

Verwenden Sie dieses einfache Plugin.

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

Installation

npm install mongoose-paginate-v2
Verwendung Fügen Sie einem Schema ein Plugin hinzu und verwenden Sie dann die Modell-Paginate-Methode:

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

Aravind NC
quelle
Dieses Plugin wurde bereits in einer anderen Antwort "vorgeschlagen". Es wäre auch hilfreich zu wissen, dass Sie einen Beitrag zu diesem Paket leisten.
lukas_o
@lukas_o Ja. Ich bin der Schöpfer des Plugins.
Aravind NC
0

gemäß

Chris Hinkle

Antworten:

//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
Mojtaba Hoseinpour
quelle
0

Mit ts-Mungo-Paginierung

    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)
Victor Fiamoncini
quelle
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.
Hemant
quelle
-1

Konnte auch mit async / await Ergebnisse erzielen.

Codebeispiel unten mit einem asynchronen Handler mit Hapi v17 und Mungo v5

{
            method: 'GET',
            path: '/api/v1/paintings',
            config: {
                description: 'Get all the paintings',
                tags: ['api', 'v1', 'all paintings']
            },
            handler: async (request, reply) => {
                /*
                 * Grab the querystring parameters
                 * page and limit to handle our pagination
                */
                var pageOptions = {
                    page: parseInt(request.query.page) - 1 || 0, 
                    limit: parseInt(request.query.limit) || 10
                }
                /*
                 * Apply our sort and limit
                */
               try {
                    return await Painting.find()
                        .sort({dateCreated: 1, dateModified: -1})
                        .skip(pageOptions.page * pageOptions.limit)
                        .limit(pageOptions.limit)
                        .exec();
               } catch(err) {
                   return err;
               }

            }
        }
csichar
quelle