Come posso sapere il conteggio di un modello di cui sono stati salvati i dati? c'è un metodo di Model.count(), ma non sembra funzionare.

var db = mongoose.connect('mongodb://localhost/myApp');
var userSchema = new Schema({name:String,password:String});
userModel =db.model('UserList',userSchema);        
var userCount = userModel.count('name');

userCountè un oggetto, quale metodo chiamato può ottenere un vero count?

Grazie

Il codice seguente funziona. Nota l'uso di countDocuments .

 var mongoose = require('mongoose');
 var db = mongoose.connect('mongodb://localhost/myApp');
 var userSchema = new mongoose.Schema({name:String,password:String});
 var userModel =db.model('userlists',userSchema);
 var anand = new userModel({ name: 'anand', password: 'abcd'});
 anand.save(function (err, docs) {
   if (err) {
       console.log('Error');
   } else {
       userModel.countDocuments({name: 'anand'}, function(err, c) {
           console.log('Count is ' + c);
      });
   }
 }); 

Il motivo per cui il codice non funziona è perché la funzione di conteggio è asincrona, non restituisce un valore in modo sincrono.

Ecco un esempio di utilizzo:

userModel.count({}, function( err, count){
    console.log( "Number of users:", count );
})

Collection.count è deprecato e verrà rimosso in una versione futura. Usa raccolta. countDocuments o collezione. stimatoDocumentCount invece.

userModel.countDocuments(query).exec((err, count) => {
    if (err) {
        res.send(err);
        return;
    }

    res.json({ count: count });
});

Dovresti dare un oggetto come argomento

userModel.count({name: "sam"});

o

userModel.count({name: "sam"}).exec(); //if you are using promise

o

userModel.count({}); // if you want to get all counts irrespective of the fields

Nella versione recente di mongoose, count () è deprecato, quindi usa

userModel.countDocuments({name: "sam"});

Sfondo per la soluzione

Come affermato nella documentazione di mongoose e nella risposta di Benjamin, il metodo Model.count()è deprecato. Invece di utilizzare count(), le alternative sono le seguenti:

Model.countDocuments(filterObject, callback)

Conta quanti documenti corrispondono al filtro in una raccolta. Il passaggio di un oggetto vuoto {} come filtro esegue una scansione completa della raccolta. Se la raccolta è grande, potrebbe essere utilizzato il seguente metodo.

Model.estimatedDocumentCount()

Questo metodo modello stima il numero di documenti nella raccolta MongoDB. Questo metodo è più veloce del precedente countDocuments(), perché utilizza i metadati della raccolta invece di passare attraverso l'intera raccolta. Tuttavia, come suggerisce il nome del metodo e in base alla configurazione del database, il risultato è una stima poiché i metadati potrebbero non riflettere il conteggio effettivo dei documenti in una raccolta al momento dell'esecuzione del metodo.

Entrambi i metodi restituiscono un oggetto query mongoose, che può essere eseguito in uno dei due modi seguenti. Utilizzare .exec()se si desidera eseguire una query in un secondo momento.

La soluzione

Opzione 1: passare una funzione di callback

Ad esempio, conta tutti i documenti in una raccolta utilizzando .countDocuments():

someModel.countDocuments({}, function(err, docCount) {
    if (err) { return handleError(err) } //handle possible errors
    console.log(docCount)
    //and do some other fancy stuff
})

In alternativa, conta tutti i documenti in una raccolta con un determinato nome utilizzando .countDocuments():

someModel.countDocuments({ name: 'Snow' }, function(err, docCount) {
    //see other example
}

Opzione 2: utilizzare .then()

Una query mangusta ha .then() quindi è "quindi modificabile". Questo è per comodità e la query in sé non è una promessa.

Ad esempio, conta tutti i documenti in una raccolta utilizzando .estimatedDocumentCount():

someModel
    .estimatedDocumentCount()
    .then(docCount => {
        console.log(docCount)
        //and do one super neat trick
    })
    .catch(err => {
        //handle possible errors
    })

Opzione 3: usa async / await

Quando si usa l'approccio async / await, il modo consigliato è usarlo con .exec()in quanto fornisce migliori tracce dello stack.

const docCount = await someModel.countDocuments({}).exec();

Imparando da stackoverflow,

Le risposte con il voto più alto qui vanno perfettamente bene, voglio solo sommare l'uso di await in modo che la funzionalità richiesta possa essere archiviata:

const documentCount = await userModel.count({});
console.log( "Number of users:", documentCount );

Si consiglia di usare countDocuments () su 'count ()' poiché sarà deprecato in corso. Quindi, per ora, il codice perfetto sarebbe:

const documentCount = await userModel.countDocuments({});
console.log( "Number of users:", documentCount );

Come detto prima, il codice non funzionerà nel modo in cui è. Una soluzione a questo sarebbe utilizzare una funzione di callback, ma se pensi che ti porterebbe a un "inferno di richiamata", puoi cercare "Promisses".

Una possibile soluzione utilizzando una funzione di callback:

//DECLARE  numberofDocs OUT OF FUNCTIONS
     var  numberofDocs;
     userModel.count({}, setNumberofDocuments); //this search all DOcuments in a Collection

se vuoi cercare il numero di documenti in base a una query, puoi farlo:

 userModel.count({yourQueryGoesHere}, setNumberofDocuments);

setNumberofDocuments è una funzione separata:

var setNumberofDocuments = function(err, count){ 
        if(err) return handleError(err);

        numberofDocs = count;

      };

Ora puoi ottenere il numero di documenti ovunque con getFunction:

     function getNumberofDocs(){
           return numberofDocs;
        }
 var number = getNumberofDocs();

Inoltre, si utilizza questa funzione asincrona all'interno di una sincrona utilizzando un callback, ad esempio:

function calculateNumberOfDoc(someParameter, setNumberofDocuments){

       userModel.count({}, setNumberofDocuments); //this search all DOcuments in a Collection

       setNumberofDocuments(true);


} 

Spero che possa aiutare gli altri. :)