Skąd mogę wiedzieć, ile modeli zostało zapisanych? jest metoda Model.count(), ale wydaje się, że nie działa.

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

userCountjest obiektem, która wywołana metoda może uzyskać wartość rzeczywistą count?

Dzięki

Poniższy kod działa. Zwróć uwagę na użycie 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);
      });
   }
 }); 

Kod nie działa, ponieważ funkcja count jest asynchroniczna i nie zwraca synchronicznie wartości.

Oto przykład użycia:

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

Collection.count jest przestarzała i zostanie usunięta w przyszłej wersji. Użyj kolekcji. countDocuments lub collection. Zamiast tego oszacowanoDocumentCount .

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

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

Jako argument należy podać obiekt

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

lub

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

lub

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

W najnowszej wersji mongoose funkcja count () jest przestarzała, więc użyj

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

Tło rozwiązania

Jak stwierdzono w dokumentacji mangusty i w odpowiedzi Benjamina, metoda Model.count()jest przestarzała. Zamiast używać count(), alternatywy są następujące:

Model.countDocuments(filterObject, callback)

Oblicza, ile dokumentów pasuje do filtra w kolekcji. Przekazanie pustego obiektu {} jako filtru powoduje wykonanie pełnego skanowania kolekcji. Jeśli kolekcja jest duża, można użyć następującej metody.

Model.estimatedDocumentCount()

Ta metoda modelu szacuje liczbę dokumentów w kolekcji MongoDB. Ta metoda jest szybsza niż poprzednia countDocuments(), ponieważ używa metadanych kolekcji zamiast przechodzić przez całą kolekcję. Jednak, jak sugeruje nazwa metody, w zależności od konfiguracji bazy danych, wynikiem jest oszacowanie, ponieważ metadane mogą nie odzwierciedlać faktycznej liczby dokumentów w kolekcji w momencie wykonywania metody.

Obie metody zwracają obiekt zapytania mongoose, który można wykonać na jeden z dwóch poniższych sposobów. Użyj, .exec()jeśli chcesz wykonać zapytanie w późniejszym czasie.

Rozwiązanie

Opcja 1: Przekaż funkcję zwrotną

Na przykład policz wszystkie dokumenty w kolekcji, używając .countDocuments():

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

Lub policz wszystkie dokumenty w kolekcji o określonej nazwie, używając .countDocuments():

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

Opcja 2: Użyj .then()

Zapytanie .then()o mangustę ma, więc jest „możliwe”. To jest dla wygody, a samo zapytanie nie jest obietnicą.

Na przykład policz wszystkie dokumenty w kolekcji, używając .estimatedDocumentCount():

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

Opcja 3: użyj async / await

Korzystając z podejścia async / await, zalecanym sposobem jest użycie go z, .exec()ponieważ zapewnia lepsze ślady stosu.

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

Nauka przez przepełnienie stosu,

Najwyżej ocenione tutaj odpowiedzi są w porządku. Chcę tylko dodać użycie await, aby żądana funkcjonalność mogła zostać zarchiwizowana:

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

Zaleca się używanie funkcji countDocuments () zamiast funkcji „count ()”, ponieważ będzie ona przestarzała. Tak więc na razie idealny kod wyglądałby tak:

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

Jak wspomniano wcześniej, kod nie będzie działał tak, jak jest. Rozwiązaniem tego problemu byłoby użycie funkcji zwrotnej, ale jeśli myślisz, że zaprowadzi Cię to do „piekła oddzwonienia”, możesz wyszukać „Promisses”.

Możliwe rozwiązanie wykorzystujące funkcję zwrotną:

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

jeśli chcesz wyszukać liczbę dokumentów na podstawie zapytania, możesz to zrobić:

 userModel.count({yourQueryGoesHere}, setNumberofDocuments);

setNumberofDocuments to oddzielna funkcja:

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

        numberofDocs = count;

      };

Teraz możesz uzyskać liczbę dokumentów w dowolnym miejscu dzięki funkcji getFunction:

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

Ponadto tej funkcji asynchronicznej używa się wewnątrz funkcji synchronicznej, używając wywołania zwrotnego, na przykład:

function calculateNumberOfDoc(someParameter, setNumberofDocuments){

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

       setNumberofDocuments(true);


} 

Mam nadzieję, że może pomóc innym. :)