Que sont les mangoustes dans le nœud

Dans Node, mongooes est un module tiers et une bibliothèque ODM (Object Document Model). Il optimise et encapsule en outre le module MongoDB natif de Node et peut faire fonctionner la base de données MongoDB en exploitant le modèle objet.

L'environnement d'exploitation de ce tutoriel : système windows7, nodejs version 12.19.0, ordinateur DELL G3.

Mongoose

Mongoose est un module de Nodejs. Ce module peut faire fonctionner le module MongoDB pour faire fonctionner la base de données

Mongooose est une bibliothèque de modèle de document objet (ODM), qui optimise et encapsule davantage le module MongoDB natif de Node. . et fournit plus de fonctions.

Mongoose est un outil de modèle objet pour MongoDB. Il s'agit d'un pilote nodejs pour MongoDB développé sur la base de node-mongodb-native. C'est également actuellement la bibliothèque préférée de Node.js pour faire fonctionner MongoDB.

Avantages de Mongoose

• Peut créer une structure de schéma (contrainte) (Schéma) pour le document

• Peut effectuer une validation sur des objets/documents dans le modèle

• Les données peuvent être converties en modèle objet par type

• Vous pouvez utiliser un middleware pour appliquer des hooks de logique métier

• C'est plus facile que le pilote MongoDB natif de Node

Remarque : pour l'utiliser, vous devez d'abord installer node.js et mongodb.

installation de mangouste

npm install mongoose

Après une installation réussie, comme indiqué ci-dessous :

Après une installation réussie, vous pouvez l'utiliser via require('mongoose') !

Chaîne de connexion

Créez un 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');  
});

Appelez le nœud db.js pour l'exécuter et vous verrez le résultat comme indiqué ci-dessous

Comme vous pouvez le voir dans le code, plusieurs événements sont surveillé. Et l'exécution déclenche l'événement connecté, ce qui signifie que la connexion est réussie

Il y a plus que les événements ci-dessus dans la connexion. La clé dépend de l'événement que vous souhaitez surveiller.

　 D'autres événements peuvent être consultés par vous-même : http://mongoosejs.com/docs/api.html#connection_Connection

　 Il s'agit de la chaîne de connexion la plus simple. Bien sûr, il existe d'autres formes, telles que : mot de passe de connexion, connexion à la base de données. les paramètres, les méthodes de cluster, les types de connexion, etc. sont expliqués ici. Vérifiez vous-même la documentation de l'API lorsque vous l'utilisez http://mongoosejs.com/docs/api.html#index-js

Schema

Schema est. utilisé dans mangoose Un schéma de données peut être compris comme la définition d'une structure de table ; chaque schéma sera mappé à une collection dans mongodb, qui n'a pas la capacité de faire fonctionner la base de données

Nous transformons d'abord db.js et exportons la mangouste object

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;

Ensuite, nous définissons le schéma d'un utilisateur, nommé user.js

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

Définir un schéma est aussi simple que cela, spécifions le nom et le type du champ

Les types de schéma intégrés sont les suivants :

• String

• Nombre

• Booléen | Buffer

• Date

• ObjectId | Oid

• Mixed

• Vous pouvez également faire des choses courantes dans Schema, dont je parlerai plus tard !

• Modèle

  Après avoir défini le schéma, l'étape suivante consiste à générer le modèle. 　 Le modèle est un modèle généré par schéma, qui peut faire fonctionner la base de données

Nous générons un modèle utilisateur pour le schéma de l'utilisateur défini ci-dessus et l'exportons. Le code modifié est le suivant

/**
 * 用户信息 */
 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);

Opérations courantes de base de données

Suivant Créer. un fichier test.js pour démontrer certaines opérations courantes.

　Insérer

　

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

　Le résultat est visualisé dans l'outil robmongo

Sur la photo, vous pouvez voir que le l'insertion a réussi !

　　更新 

　　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 教程！

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!