suchen

Heim >Web-Frontend >Front-End-Fragen und Antworten >Was sind Mungos im Knoten?

Was sind Mungos im Knoten?

青灯夜游
青灯夜游Original
2022-03-22 17:16:342055Durchsuche

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

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

    • Modell

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

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

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

    　　图中可以看出，密码更新成功！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();

    　　其它更新方法

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

    　　结果就不贴了，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 = {'username' : 'Tracy McGrady'};
    
    User.find(wherestr, function(err, res){
        if (err) {
            console.log("Error:" + err);
        }
        else {
            console.log("Res:" + res);
        }
    })
}

getByConditions();

    　　结果我就不展示了

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

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

function getByConditions(){
    var wherestr = {'username' : 'Tracy McGrady'};
    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();

    　　输出只会有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();

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

    　　根据_id查询

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

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

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

getById();

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

    　　模糊查询

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

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

getByRegex();

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

    　　分页查询

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

function getByPager(){
    
    var pageSize = 5;                   //一页多少条
    var currentPage = 1;                //当前第几页
    var sort = {'logindate':-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();

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

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

    其它操作

    　　其它还有比较多常用的

    　　索引和默认值

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

    /**
 * 用户信息
 */
var mongoose = require('./db.js'),
    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('User',UserSchema);

    　　index ：建索引

    　　default：默认值

    　　LBS地址位置

    lbs : { type: Array, index: '2d', sparse: true }   //地理位置

    　　上面有介绍过很多基于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!

    JavaScript mysql node.js 中间件 html count sort 封装 require 字符串 Regex Collection 类型转换 JS 对象 事件 default mongodb 数据库 http
    Stellungnahme：
    Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn
    Vorheriger Artikel：Was soll ich tun, wenn die Ausführung von „node -v“ zeigt, dass „node“ kein interner oder externer Befehl ist?Nächster Artikel：Was soll ich tun, wenn die Ausführung von „node -v“ zeigt, dass „node“ kein interner oder externer Befehl ist?

    In Verbindung stehende Artikel

    Mehr sehen