Was sind Mungos im Knoten?-Front-End-Fragen und Antworten-php.cn

In Node ist mongooes ein Drittanbietermodul und eine Object Document Model (ODM)-Bibliothek. Es optimiert und kapselt das native MongoDB-Modul von Node und kann die MongoDB-Datenbank durch Betreiben des Objektmodells betreiben.

Was sind Mungos im Knoten?

Die Betriebsumgebung dieses Tutorials: Windows7-System, NodeJS-Version 12.19.0, DELL G3-Computer.

Mongoose

Mongoose ist ein Modul von Nodejs, um die Datenbank zu betreiben.

Mongoose ist eine Object Document Model (ODM)-Bibliothek, die das native MongoDB-Modul weiter optimiert und kapselt . und bietet weitere Funktionen.

Mongoose ist ein Objektmodell-Tool für MongoDB, das auf Basis von node-mongodb-native entwickelt wurde. Es ist derzeit auch die bevorzugte Bibliothek für Node.js zum Betrieb von MongoDB.

Vorteile von Mongoose

Kann eine Schemastruktur (Einschränkung) (Schema) für das Dokument erstellen
Kann eine Validierung für Objekte/Dokumente im Modell durchführen
Daten können in ein Objektmodell konvertiert werden nach Typ
Sie können Middleware verwenden, um Geschäftslogik-Hooks anzuwenden
Es ist einfacher als der native MongoDB-Treiber von Node

Hinweis: Um es zu verwenden, müssen Sie zuerst node.js und mongodb installieren.

Mongoose-Installation

npm install mongoose

Nach dem Login kopieren

Nach erfolgreicher Installation, wie unten gezeigt:

Nach erfolgreicher Installation können Sie es über require('mongoose') verwenden!

Verbindungszeichenfolge

Erstellen Sie ein db.js

var mongoose = require('mongoose'),
    DB_URL = 'mongodb://localhost:27017/mongoosesample';/**
 * 连接 */mongoose.connect(DB_URL);/**
  * 连接成功  */mongoose.connection.on('connected', function () {    
    console.log('Mongoose connection open to ' + DB_URL);  
});    

/**
 * 连接异常 */mongoose.connection.on('error',function (err) {    
    console.log('Mongoose connection error: ' + err);  
});    
 
/**
 * 连接断开 */mongoose.connection.on('disconnected', function () {    
    console.log('Mongoose connection disconnected');  
});

Nach dem Login kopieren

Rufen Sie den Knoten db.js zur Ausführung auf und Sie sehen die Ausgabe wie unten gezeigt

Wie Sie dem Code entnehmen können, sind mehrere Ereignisse vorhanden Überwacht. Und die Ausführung löst das verbundene Ereignis aus, was bedeutet, dass die Verbindung erfolgreich ist. Es gibt mehr als die oben genannten Ereignisse in der Verbindung. Der Schlüssel hängt davon ab, welches Ereignis Sie überwachen möchten.

　 Andere Ereignisse können Sie selbst anzeigen: http://mongoosejs.com/docs/api.html#connection_Connection

　 Dies ist natürlich die einfachste Verbindungszeichenfolge, wie zum Beispiel: Verbindungspasswort, Datenbankverbindung Einstellungen, Cluster-Methoden, Verbindungstypen usw. werden hier erklärt, wenn Sie sie verwenden: http://mongoosejs.com/docs/api.html#index-js

Schema Wird in Mongoose verwendet. Ein Datenschema kann als Definition einer Tabellenstruktur verstanden werden. Jedes Schema wird einer Sammlung in Mongodb zugeordnet, die nicht über die Fähigkeit verfügt, die Datenbank zu betreiben. Wir transformieren zuerst db.js und exportieren den Mongoose Objekt

var mongoose = require('mongoose'),
    DB_URL = 'mongodb://localhost:27017/mongoosesample';/**
 * 连接 */mongoose.connect(DB_URL);/**
  * 连接成功  */mongoose.connection.on('connected', function () {    
    console.log('Mongoose connection open to ' + DB_URL);  
});    

/**
 * 连接异常 */mongoose.connection.on('error',function (err) {    
    console.log('Mongoose connection error: ' + err);  
});    
 
/**
 * 连接断开 */mongoose.connection.on('disconnected', function () {    
    console.log('Mongoose connection disconnected');  
});    

module.exports = mongoose;

Nach dem Login kopieren

Als nächstes definieren wir ein Benutzerschema mit dem Namen user.js

 mongoose = require('./db.js'= UserSchema = 
    userpwd: {type: String},                        
    userage: {type: Number},                        
    logindate : { type: Date}

Nach dem Login kopieren

So einfach ist das Definieren eines Schemas: Geben Sie den Feldnamen und den Feldtyp an. Die integrierten Schematypen sind wie folgt:

String

Zahl
Boolean |
Puffer
Datum
ObjectId |. Oid
Mixed
Sie können auch einige allgemeine Dinge in Schema tun, über die ich später sprechen werde!
Nach der Definition des Schemas besteht der nächste Schritt darin, das Modell zu generieren. 　 Modell ist ein vom Schema generiertes Modell, das die Datenbank betreiben kann.
Wir generieren ein Benutzermodell für das oben definierte Schema des Benutzers und exportieren es. Der geänderte Code lautet wie folgt:

/**
 * 用户信息 */
 var mongoose = require('./db.js'),
    Schema = mongoose.Schema;var UserSchema = new Schema({          
    username : { type: String },                    //用户账号
    userpwd: {type: String},                        //密码
    userage: {type: Number},                        //年龄
    logindate : { type: Date}                       //最近登录时间
 });
 module.exports = mongoose.model('User',UserSchema);

Nach dem Login kopieren

Allgemeine Datenbankoperationen Weiter erstellen eine test.js-Datei, um einige gängige Vorgänge zu demonstrieren.

　Einfügen

Model#save([fn])

var User = require("./user.js");
/**
 * 插入 
*/
 function insert() { 
    var user = new User({
        username : 'Tracy McGrady',                 //用户账号
        userpwd: 'abcd',                            //密码
        userage: 37,                                //年龄
        logindate : new Date()                      //最近登录时间    
    });

    user.save(function (err, res) {     
       if (err) {
            console.log("Error:" + err);
        }        else {
            console.log("Res:" + res);
        }

    });
}

insert();

Nach dem Login kopieren

　Das Ergebnis wird im Robmongo-Tool angezeigt Sehen Sie, dass das Einfügen erfolgreich war!

　　更新

　　Model.update(conditions, update, [options], [callback])

var User = require("./user.js");function update(){
    var wherestr = {'username' : 'Tracy McGrady'};    
    var updatestr = {'userpwd': 'zzzz'};
    
    User.update(wherestr, updatestr, function(err, res){  
       if (err) {
            console.log("Error:" + err);
        }        else {
            console.log("Res:" + res);
        }
    })
}

update();

Nach dem Login kopieren

　　根据用户名更新密码，执行后结果如图

　　图中可以看出，密码更新成功！update方法基本可以满足所有更新！

　　常用方法还有findByIdAndUpdate，这种比较有指定性，就是根据_id

　　Model.findByIdAndUpdate(id, [update], [options], [callback])

var User = require("./user.js");function findByIdAndUpdate(){
    var id = '56f2558b2dd74855a345edb2';    
    var updatestr = {'userpwd': 'abcd'};
    
    User.findByIdAndUpdate(id, updatestr, function(err, res){     
       if (err) {
            console.log("Error:" + err);
        }        else {
            console.log("Res:" + res);
        }
    })
}

findByIdAndUpdate();

Nach dem Login kopieren

　　其它更新方法

　　Model.findOneAndUpdate([conditions], [update], [options], [callback])　　　　　　//找到一条记录并更新

　　删除

　　Model.remove(conditions, [callback])

var User = require("./user.js");function del(){
    var wherestr = {'username' : 'Tracy McGrady'};
    
    User.remove(wherestr, function(err, res){
        if (err) {
            console.log("Error:" + err);
        }        else {
            console.log("Res:" + res);
        }
    })
}

del();

Nach dem Login kopieren

　　结果就不贴了，res中会返回是否成功以及影响的行数：{"ok":1,"n":1}

　　其它常用方法还有：

　　Model.findByIdAndRemove(id, [options], [callback])　　　　　　

　　Model.findOneAndRemove(conditions, [options], [callback])

　　条件查询

　　已先插入一些测试数据。。

　　Model.find(conditions, [fields], [options], [callback])

var User = require("./user.js");

function getByConditions(){
    var wherestr = {&#39;username&#39; : &#39;Tracy McGrady&#39;};
    
    User.find(wherestr, function(err, res){
        if (err) {
            console.log("Error:" + err);
        }
        else {
            console.log("Res:" + res);
        }
    })
}

getByConditions();

Nach dem Login kopieren

　　结果我就不展示了

　　第2个参数可以设置要查询输出的字段,比如改成

var User = require("./user.js");

function getByConditions(){
    var wherestr = {&#39;username&#39; : &#39;Tracy McGrady&#39;};
    var opt = {"username": 1 ,"_id": 0};
    
    User.find(wherestr, opt, function(err, res){
        if (err) {
            console.log("Error:" + err);
        }
        else {
            console.log("Res:" + res);
        }
    })
}

getByConditions();

Nach dem Login kopieren

　　输出只会有username字段，设置方法如上，1表示查询输出该字段，0表示不输出

　　比如我要查询年龄范围条件应该怎么写呢？

　　User.find({userage: {$gte: 21, $lte: 65}}, callback); //这表示查询年龄大于等21而且小于等于65岁

　　其实类似的还有：　

　　$or　　　　或关系

　　$nor　　　或关系取反

　　$gt　　　　大于

　　$gte　　　大于等于

　　$lt　　　　小于

　　$lte　　　小于等于

　　$ne 不等于

　　$in 在多个值范围内

　　$nin 不在多个值范围内

　　$all 匹配数组中多个值

　　$regex　　正则，用于模糊查询

　　$size　　　匹配数组大小

　　$maxDistance　　范围查询，距离（基于LBS）

　　$mod　　取模运算

　　$near　　　邻域查询，查询附近的位置（基于LBS）

　　$exists　　字段是否存在

　　$elemMatch　　匹配内数组内的元素

　　$within　　范围查询（基于LBS）

　　$box　　　范围查询，矩形范围（基于LBS）

　　$center 范围醒询，圆形范围（基于LBS）

　　$centerSphere　　范围查询，球形范围（基于LBS）

　　$slice　　　　查询字段集合中的元素（比如从第几个之后，第N到第M个元素）

　　可能还有一些，没什么印象，大家自行看看api ^_^!　　

　　数量查询

　　Model.count(conditions, [callback])

var User = require("./user.js");

function getCountByConditions(){
    var wherestr = {};
    
    User.count(wherestr, function(err, res){
        if (err) {
            console.log("Error:" + err);
        }
        else {
            console.log("Res:" + res);
        }
    })
}
getCountByConditions();

Nach dem Login kopieren

　　res会输出数量，也可以传入条件做条件查询！

　　根据_id查询

　　Model.findById(id, [fields], [options], [callback])

var User = require("./user.js");

function getById(){
    var id = &#39;56f261fb448779caa359cb73&#39;;
    
    User.findById(id, function(err, res){
        if (err) {
            console.log("Error:" + err);
        }
        else {
            console.log("Res:" + res);
        }
    })
}

getById();

Nach dem Login kopieren

　　这个还是比较常用，要据ID得到数据！　　

　　模糊查询

var User = require("./user.js");

function getByRegex(){
    var whereStr = {&#39;username&#39;:{$regex:/m/i}};
    
    User.find(whereStr, function(err, res){
        if (err) {
            console.log("Error:" + err);
        }
        else {
            console.log("Res:" + res);
        }
    })
}

getByRegex();

Nach dem Login kopieren

　　上面示例中查询出所有用户名中有'm'的名字，且不区分大小写，模糊查询比较常用，正则形式匹配，正则方式就是javascript正则，用到的比较多！

　　分页查询

var User = require("./user.js");

function getByPager(){
    
    var pageSize = 5;                   //一页多少条
    var currentPage = 1;                //当前第几页
    var sort = {&#39;logindate&#39;:-1};        //排序（按登录时间倒序）
    var condition = {};                 //条件
    var skipnum = (currentPage - 1) * pageSize;   //跳过数
    
    User.find(condition).skip(skipnum).limit(pageSize).sort(sort).exec(function (err, res) {
        if (err) {
            console.log("Error:" + err);
        }
        else {
            console.log("Res:" + res);
        }
    })
}

getByPager();

Nach dem Login kopieren

　　分页是用得比较多的查询，分页原理用过其它数据库的都知道，分页用到的函数和mysql的比较类似

　　上面我用到sort(),这个是排序规则，就不单讲了！

其它操作

　　其它还有比较多常用的

　　索引和默认值

　　再看看我对user.js这个schema的修改

/**
 * 用户信息
 */
var mongoose = require(&#39;./db.js&#39;),
    Schema = mongoose.Schema;

var UserSchema = new Schema({          
    username : { type: String , index: true},                    //用户账号
    userpwd: {type: String},                        //密码
    userage: {type: Number},                        //年龄
    logindate : { type: Date, default:Date.now}                       //最近登录时间
});

module.exports = mongoose.model(&#39;User&#39;,UserSchema);

Nach dem Login kopieren

　　index ：建索引

　　default：默认值

　　LBS地址位置

lbs : { type: Array, index: &#39;2d&#39;, sparse: true }   //地理位置

Nach dem Login kopieren

　　上面有介绍过很多基于LBS的条件查询，Schema中定义时如上

　　LBS查询对于一些基于LBS应用会用得比较多。

　　其它常用方法

　　Model.distinct(field, [conditions], [callback])　　　　　　　　　　　　　　　　　　//去重

　　Model.findOne(conditions, [fields], [options], [callback])　　　　　　　　　　　　 //查找一条记录

　　Model.findOneAndRemove(conditions, [options], [callback])　　　　　　　　　　 //查找一条记录并删除

　　Model.findOneAndUpdate([conditions], [update], [options], [callback])　　　　　 //查找一条记录并更新

更多node相关知识，请访问：nodejs 教程！

Das obige ist der detaillierte Inhalt vonWas sind Mungos im Knoten?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!