Node.js => Biblioteka Mongoose

Połącz z MongoDB za pomocą Mongoose

Najpierw zainstaluj Mongoose z:

npm install mongoose

Następnie dodaj go do server.js jako zależności:

var mongoose = require('mongoose');
var Schema = mongoose.Schema;

Następnie utwórz schemat bazy danych i nazwę kolekcji:

var schemaName = new Schema({
    request: String,
    time: Number
}, {
    collection: 'collectionName'
});

Utwórz model i połącz się z bazą danych:

var Model = mongoose.model('Model', schemaName);
mongoose.connect('mongodb://localhost:27017/dbName');

Następnie uruchom MongoDB i uruchom server.js za pomocą node server.js

Aby sprawdzić, czy udało nam się połączyć z bazą danych, możemy użyć zdarzeń open , error z obiektu mongoose.connection .

var db = mongoose.connection;
db.on('error', console.error.bind(console, 'connection error:'));
db.once('open', function() {
  // we're connected!
});

Zapisz dane w MongoDB przy użyciu tras Mongoose i Express.js

Ustawiać

Najpierw zainstaluj niezbędne pakiety z:

npm install express cors mongoose

Kod

Następnie dodaj zależności do pliku server.js , utwórz schemat bazy danych i nazwę kolekcji, utwórz serwer Express.js i połącz się z MongoDB:

var express = require('express');
var cors = require('cors'); // We will use CORS to enable cross origin domain requests.
var mongoose = require('mongoose');
var Schema = mongoose.Schema;

var app = express();

var schemaName = new Schema({
    request: String,
    time: Number
}, {
    collection: 'collectionName'
});

var Model = mongoose.model('Model', schemaName);
mongoose.connect('mongodb://localhost:27017/dbName');

var port = process.env.PORT || 8080;
app.listen(port, function() {
    console.log('Node.js listening on port ' + port);
});

Teraz dodaj trasy Express.js, których użyjemy do zapisania danych:

app.get('/save/:query', cors(), function(req, res) {
    var query = req.params.query;

    var savedata = new Model({
        'request': query,
        'time': Math.floor(Date.now() / 1000) // Time of save the data in unix timestamp format
    }).save(function(err, result) {
        if (err) throw err;

        if(result) {
            res.json(result)
        }
    })
})

Tutaj zmienną query będzie parametr <query> z przychodzącego żądania HTTP, który zostanie zapisany w MongoDB:

var savedata = new Model({
    'request': query,
    //...

Jeśli podczas próby zapisu do MongoDB wystąpi błąd, na konsoli pojawi się komunikat o błędzie. Jeśli wszystko się powiedzie, zobaczysz zapisane dane w formacie JSON na stronie.

//...
}).save(function(err, result) {
    if (err) throw err;

    if(result) {
        res.json(result)
    }
})
//...

Teraz musisz uruchomić MongoDB i uruchomić plik server.js za pomocą node server.js .

Stosowanie

Aby użyć tego do zapisania danych, przejdź do następującego adresu URL w przeglądarce:

http://localhost:8080/save/<query>

Gdzie <query> to nowe żądanie, które chcesz zapisać.

Przykład:

http://localhost:8080/save/JavaScript%20is%20Awesome

Dane wyjściowe w formacie JSON:

{
    __v: 0,
    request: "JavaScript is Awesome",
    time: 1469411348,
    _id: "57957014b93bc8640f2c78c4"
}

Znajdź dane w MongoDB przy użyciu tras Mongoose i Express.js

Ustawiać

Najpierw zainstaluj niezbędne pakiety z:

npm install express cors mongoose

Kod

Następnie dodaj zależności do server.js , utwórz schemat bazy danych i nazwę kolekcji, utwórz serwer Express.js i połącz się z MongoDB:

var express = require('express');
var cors = require('cors'); // We will use CORS to enable cross origin domain requests.
var mongoose = require('mongoose');
var Schema = mongoose.Schema;

var app = express();

var schemaName = new Schema({
    request: String,
    time: Number
}, {
    collection: 'collectionName'
});

var Model = mongoose.model('Model', schemaName);
mongoose.connect('mongodb://localhost:27017/dbName');

var port = process.env.PORT || 8080;
app.listen(port, function() {
    console.log('Node.js listening on port ' + port);
});

Teraz dodaj trasy Express.js, których użyjemy do zapytania danych:

app.get('/find/:query', cors(), function(req, res) {
    var query = req.params.query;

    Model.find({
        'request': query
    }, function(err, result) {
        if (err) throw err;
        if (result) {
            res.json(result)
        } else {
            res.send(JSON.stringify({
                error : 'Error'
            }))
        }
    })
})

Załóżmy, że następujące dokumenty znajdują się w kolekcji w modelu:

{
        "_id" : ObjectId("578abe97522ad414b8eeb55a"),
        "request" : "JavaScript is Awesome",
        "time" : 1468710551
}
{
        "_id" : ObjectId("578abe9b522ad414b8eeb55b"),
        "request" : "JavaScript is Awesome",
        "time" : 1468710555
}
{
        "_id" : ObjectId("578abea0522ad414b8eeb55c"),
        "request" : "JavaScript is Awesome",
        "time" : 1468710560
}

Celem jest znalezienie i wyświetlenie wszystkich dokumentów zawierających "JavaScript is Awesome" pod kluczem "request" .

W tym celu uruchom MongoDB i uruchom server.js z node server.js :

Stosowanie

Aby użyć tego do wyszukiwania danych, przejdź do następującego adresu URL w przeglądarce:

http://localhost:8080/find/<query>

Gdzie <query> to zapytanie wyszukiwania.

Przykład:

http://localhost:8080/find/JavaScript%20is%20Awesome

Wynik:

[{
    _id: "578abe97522ad414b8eeb55a",
    request: "JavaScript is Awesome",
    time: 1468710551,
    __v: 0
},
{
    _id: "578abe9b522ad414b8eeb55b",
    request: "JavaScript is Awesome",
    time: 1468710555,
    __v: 0
},
{
    _id: "578abea0522ad414b8eeb55c",
    request: "JavaScript is Awesome",
    time: 1468710560,
    __v: 0
}]

Znajdź dane w MongoDB przy użyciu Mongoose, tras Express.js i operatora $ text

Ustawiać

Najpierw zainstaluj niezbędne pakiety z:

npm install express cors mongoose

Kod

Następnie dodaj zależności do server.js , utwórz schemat bazy danych i nazwę kolekcji, utwórz serwer Express.js i połącz się z MongoDB:

var express = require('express');
var cors = require('cors'); // We will use CORS to enable cross origin domain requests.
var mongoose = require('mongoose');
var Schema = mongoose.Schema;

var app = express();

var schemaName = new Schema({
    request: String,
    time: Number
}, {
    collection: 'collectionName'
});

var Model = mongoose.model('Model', schemaName);
mongoose.connect('mongodb://localhost:27017/dbName');

var port = process.env.PORT || 8080;
app.listen(port, function() {
    console.log('Node.js listening on port ' + port);
});

Teraz dodaj trasy Express.js, których użyjemy do zapytania danych:

app.get('/find/:query', cors(), function(req, res) {
    var query = req.params.query;

    Model.find({
        'request': query
    }, function(err, result) {
        if (err) throw err;
        if (result) {
            res.json(result)
        } else {
            res.send(JSON.stringify({
                error : 'Error'
            }))
        }
    })
})

Załóżmy, że następujące dokumenty znajdują się w kolekcji w modelu:

{
        "_id" : ObjectId("578abe97522ad414b8eeb55a"),
        "request" : "JavaScript is Awesome",
        "time" : 1468710551
}
{
        "_id" : ObjectId("578abe9b522ad414b8eeb55b"),
        "request" : "JavaScript is Awesome",
        "time" : 1468710555
}
{
        "_id" : ObjectId("578abea0522ad414b8eeb55c"),
        "request" : "JavaScript is Awesome",
        "time" : 1468710560
}

A celem jest znalezienie i wyświetlenie wszystkich dokumentów zawierających tylko słowo "JavaScript" pod kluczem "request" .

Aby to zrobić, najpierw utwórz indeks tekstowy dla "request" w kolekcji. W tym celu dodaj następujący kod do server.js :

schemaName.index({ request: 'text' });

I zamień:

    Model.find({
        'request': query
    }, function(err, result) {

Model.find({
    $text: {
        $search: query
    }
}, function(err, result) {

W tym przypadku używamy operatorów $text i $search MongoDB do wyszukiwania wszystkich dokumentów w kolekcji collectionName która zawiera co najmniej jedno słowo z podanego zapytania find.

Stosowanie

Aby użyć tego do wyszukiwania danych, przejdź do następującego adresu URL w przeglądarce:

http://localhost:8080/find/<query>

Gdzie <query> to zapytanie wyszukiwania.

Przykład:

http://localhost:8080/find/JavaScript

Wynik:

[{
    _id: "578abe97522ad414b8eeb55a",
    request: "JavaScript is Awesome",
    time: 1468710551,
    __v: 0
},
{
    _id: "578abe9b522ad414b8eeb55b",
    request: "JavaScript is Awesome",
    time: 1468710555,
    __v: 0
},
{
    _id: "578abea0522ad414b8eeb55c",
    request: "JavaScript is Awesome",
    time: 1468710560,
    __v: 0
}]

Indeksy w modelach.

MongoDB obsługuje indeksy wtórne. W Mongoose definiujemy te indeksy w naszym schemacie. Definiowanie indeksów na poziomie schematu jest konieczne, gdy musimy utworzyć indeksy złożone.

Połączenie mangusty

var strConnection = 'mongodb://localhost:27017/dbName';
var db = mongoose.createConnection(strConnection)

Tworzenie podstawowego schematu

var Schema = require('mongoose').Schema;
var usersSchema = new Schema({
    username: {
        type: String,
        required: true,
        unique: true
    },
    email: {
        type: String,
        required: true
    },
    password: {
        type: String,
        required: true
    },
    created: {
        type: Date,
        default: Date.now
    }
});

var usersModel = db.model('users', usersSchema);
module.exports = usersModel;

Domyślnie mangusta dodaje dwa nowe pola do naszego modelu, nawet jeśli nie są one zdefiniowane w modelu. Te pola to:

_ID

Mongoose domyślnie przypisuje każdemu ze schematów pole _id, jeśli nie zostanie przekazane do konstruktora schematu. Przypisany typ to ObjectId, który pokrywa się z domyślnym zachowaniem MongoDB. Jeśli nie chcesz wcale dodawać _id do swojego schematu, możesz go wyłączyć za pomocą tej opcji.

var usersSchema = new Schema({
    username: {
        type: String,
        required: true,
        unique: true
    }, {
        _id: false 
});

__v lub versionKey

VersionKey jest właściwością ustawianą w każdym dokumencie, gdy został utworzony po raz pierwszy przez Mongoose. Ta wartość kluczy zawiera wewnętrzną wersję dokumentu. Nazwę tej właściwości dokumentu można konfigurować.

Możesz łatwo wyłączyć to pole w konfiguracji modelu:

var usersSchema = new Schema({
    username: {
        type: String,
        required: true,
        unique: true
    }, {
    versionKey: false 
});

Indeksy złożone

Możemy tworzyć kolejne indeksy oprócz tych tworzonych przez Mongoose.

usersSchema.index({username: 1 });
usersSchema.index({email: 1 });

W takim przypadku nasz model ma jeszcze dwa indeksy, jeden dla nazwy użytkownika pola i drugi dla pola adresu e-mail. Ale możemy tworzyć indeksy złożone.

usersSchema.index({username: 1, email: 1 });

Wpływ na wydajność indeksu

Domyślnie mangusta zawsze wywołuje sekwencję sureIndex dla każdego indeksu sekwencyjnie i emituje zdarzenie „indeks” w modelu, gdy wszystkie wywołania sureIndex zakończą się powodzeniem lub wystąpi błąd.

W MongoDB upewnij się, że indeks ISI jest przestarzały od wersji 3.0.0, teraz jest aliasem dla createIndex.

Zaleca się wyłączenie tego zachowania poprzez ustawienie opcji autoIndex schematu na false lub globalnie w połączeniu poprzez ustawienie opcji config.autoIndex na false.

usersSchema.set('autoIndex', false);

Przydatne funkcje Mongoose

Mongoose zawiera niektóre wbudowane funkcje oparte na standardowym find() .

doc.find({'some.value':5},function(err,docs){
    //returns array docs
});

doc.findOne({'some.value':5},function(err,doc){
    //returns document doc
});

doc.findById(obj._id,function(err,doc){
    //returns document doc
});

znajdź dane w mongodb używając obietnic

Ustawiać

Najpierw zainstaluj niezbędne pakiety z:

npm install express cors mongoose

Kod

Następnie dodaj zależności do server.js , utwórz schemat bazy danych i nazwę kolekcji, utwórz serwer Express.js i połącz się z MongoDB:

var express = require('express');
var cors = require('cors'); // We will use CORS to enable cross origin domain requests.
var mongoose = require('mongoose');
var Schema = mongoose.Schema;

var app = express();

var schemaName = new Schema({
    request: String,
    time: Number
}, {
    collection: 'collectionName'
});

var Model = mongoose.model('Model', schemaName);
mongoose.connect('mongodb://localhost:27017/dbName');

var port = process.env.PORT || 8080;
app.listen(port, function() {
    console.log('Node.js listening on port ' + port);
});

app.use(function(err, req, res, next) {
  console.error(err.stack);
  res.status(500).send('Something broke!');
});

app.use(function(req, res, next) {
  res.status(404).send('Sorry cant find that!');
});

Teraz dodaj trasy Express.js, których użyjemy do zapytania danych:

app.get('/find/:query', cors(), function(req, res, next) {
    var query = req.params.query;

    Model.find({
        'request': query
    })
    .exec() //remember to add exec, queries have a .then attribute but aren't promises
    .then(function(result) {
        if (result) {
            res.json(result)
        } else {
            next() //pass to 404 handler
        }
    })
    .catch(next) //pass to error handler
})

Załóżmy, że następujące dokumenty znajdują się w kolekcji w modelu:

{
        "_id" : ObjectId("578abe97522ad414b8eeb55a"),
        "request" : "JavaScript is Awesome",
        "time" : 1468710551
}
{
        "_id" : ObjectId("578abe9b522ad414b8eeb55b"),
        "request" : "JavaScript is Awesome",
        "time" : 1468710555
}
{
        "_id" : ObjectId("578abea0522ad414b8eeb55c"),
        "request" : "JavaScript is Awesome",
        "time" : 1468710560
}

Celem jest znalezienie i wyświetlenie wszystkich dokumentów zawierających "JavaScript is Awesome" pod kluczem "request" .

W tym celu uruchom MongoDB i uruchom server.js z node server.js :

Stosowanie

Aby użyć tego do wyszukiwania danych, przejdź do następującego adresu URL w przeglądarce:

http://localhost:8080/find/<query>

Gdzie <query> to zapytanie wyszukiwania.

Przykład:

http://localhost:8080/find/JavaScript%20is%20Awesome

Wynik:

[{
    _id: "578abe97522ad414b8eeb55a",
    request: "JavaScript is Awesome",
    time: 1468710551,
    __v: 0
},
{
    _id: "578abe9b522ad414b8eeb55b",
    request: "JavaScript is Awesome",
    time: 1468710555,
    __v: 0
},
{
    _id: "578abea0522ad414b8eeb55c",
    request: "JavaScript is Awesome",
    time: 1468710560,
    __v: 0
}]

Modified text is an extract of the original Stack Overflow Documentation

Licencjonowany na podstawie CC BY-SA 3.0

Nie związany z Stack Overflow

Node.js
Biblioteka Mongoose

Szukaj…

Połącz z MongoDB za pomocą Mongoose

Zapisz dane w MongoDB przy użyciu tras Mongoose i Express.js

Ustawiać

Kod

Stosowanie

Znajdź dane w MongoDB przy użyciu tras Mongoose i Express.js

Ustawiać

Kod

Stosowanie

Znajdź dane w MongoDB przy użyciu Mongoose, tras Express.js i operatora $ text

Ustawiać

Kod

Stosowanie

Indeksy w modelach.

Przydatne funkcje Mongoose

znajdź dane w mongodb używając obietnic

Ustawiać

Kod

Stosowanie