node.js+express+mongodb基础..持续更新

step 1.下载node.js

https://nodejs.org/en/

step 2.打开你的cmd

执行命令 npm install -g express

express 4.x版本中将命令工具分出来了，需要再安装一个命令工具，

执行命令“npm install -g express-generator”

step 3.下载webstorm 

http://www.jetbrains.com/webstorm/

webstorm需要license，在网上找一个就可以了。

step.4下载webstorm之后

找到你nodejs的位置，version就是你express的version。

项目结构如下

step 5.下载mongodb

https://www.mongodb.org/

推荐下载那个zip格式，不要exe格式

step 6.下载robomongo，是mongodb可视化工具

http://www.robomongo.org/

step 7 开启mongodb

打开你下载mongodb的路径：C:\Users\TANGIV\Downloads\mongodb-win32-x86_64-2008plus-3.0.6\mongodb-win32-x86_64-2008plus-3.0.6\bin

在

C:\Users\TANGIV\Downloads\mongodb-win32-x86_64-2008plus-3.0.6\mongodb-win32-x86_64-2008plus-3.0.6\ 

路径下新建文件夹\data\db

如下：

C:\Users\TANGIV\Downloads\mongodb-win32-x86_64-2008plus-3.0.6\mongodb-win32-x86_64-2008plus-3.0.6\data\db

打开命令行输入 

cd C:\Users\TANGIV\Downloads\mongodb-win32-x86_64-2008plus-3.0.6\mongodb-win32-x86_64-2008plus-3.0.6\bin

mongod --dbpath C:\Users\TANGIV\Downloads\mongodb-win32-x86_64-2008plus-3.0.6\mongodb-win32-x86_64-2008plus-3.0.6\data\db

出现提示连接到端口 27017即可

step 8 打开robomongo 连接到该端口号就可以看到：

step 9下载mongodb模块

在命令行输入：

npm install mongodb 

app.js

var express = require("express");
var app = express();
var path = require('path');

//bodyParser用于解析客户端请求的body中的内容
var bodyParser = require('body-parser');

//路由页面
var routes = require('./routes/index');

app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));

app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jade');

app.use(express.static(path.join(__dirname, 'public')));
app.use(routes);

module.exports = app;

关于bodyParser这个东西，我也不是特别理解，大家自己去找找资料吧！

index.js

var user =require('./users');
var teacher =require('./teachers');
var express = require('express');
var router = express.Router();


/* user Login verification*/
router.post('/',user.userLogin());

/* get all title */
router.post('/exam',teacher.getAllTitle());
这个文件用来做路由的分发，所有的请求都会被接收到这个页面，如果再通过不同的url调用不同的模块方法

这个语句是引用模块：
var user =require('./users');
var teacher =require('./teachers');

这里的user就是一个模块，userLogin()是它里面的一个方法
teacher也是一个模块，getAllTitle()是它里面的一个方法

users.js（路径：routes/users.js）
var userDao = require("../dao/userDao");
var mongoClient = require('mongodb').MongoClient;
var url = 'mongodb://localhost:27017/E-PeopleSmart';
exports.userLogin = function() {
    return function(req, res) {
        var account = req.body.account;
        var password = req.body.password;

        console.log(account);
        console.log(password);

        var data = {account:account, password:password};

        console.log(data);

        mongoClient.connect(url, function(err, db) {

            console.log("Connected correctly to server");

            userDao.queryUser(db, data, function(result) {
                console.log(result);
                console.log(result.length);

                if(result.length != 0) {
                    res.setHeader('Content-Type', 'text/plain');
                    res.json({code:200, status:"success", users:result});
                } else {
                    res.setHeader('Content-Type', 'text/plain');
                    res.json({code:404, status:"fail"});
                }
                db.close();
            });
        });
    }
}
用到了mongoClient来连接数据库，以上是一个简单的登录验证。

var account = req.body.account;
var password = req.body.password;
这里接收了从移动Client传来的参数,account和password都是你在客户端定义的map的key值

exports.userLogin = function() {...
这句话大概可以理解为生成了一个方法

var userDao = require("../dao/userDao");
这里引用了userDao模块，其路径为：dao/userDao.js

userDao.queryUser(db, data, function(result) {...
这里调用了userDao模块的queryUser方法，并且传入db，data就是我们的查询条件，function是一个回调方法，这里传入的参数没有固定，可以根据自己的需要传递。

userDao.js

exports.queryUser = function(db, data, callback) {
    var user = db.collection("user");
    user.find(data).toArray(function(err, result) {
        if(err) {
            console.log("Error : " + err);
            return;
        }

        callback(result);
    });
};

这里是通过查询条件找到是否存在该用户，result是查询结果，长度不为0的话，就说明存在该用户。

以下是mongodb+nodejs查询笔记：

有这样结构的表：

（1）需要的结构是内嵌文档examsGroup的某些数据，而不需要resultGroup如：

[{"examsGroup":

[{"examId":159,"examName":"^100 test","score":0},

{"examId":168,"examName":"dghv","score":0},

{"examId":169,"examName":"123","score":-1}]}]

user.find({"userName": Id}, {"_id": 0,"examsGroup.examId":1,"examsGroup.examName": 1,"examsGroup.score": 1}).toArray(function (err, result) {
        if (!err) {

            callback(result);
        }
        else {
            console.log(err);
        }


    });

find(查询条件,显示条件).toArray(回调方法)

显示条件，想要显示的值就设置为1，其余没有被设置为1的值都不会显示，但是"_id"这个值除外，它需要手动设置为0

（2）需要内嵌文档examGroups的某一对象，就是图中的examGroups下的0.1.2……等等

<span style="font-family:Arial;font-size:10px;"></span><pre name="code" class="javascript"><span style="font-family:Arial;font-size:10px;">user.find({"userName": userName,"examsGroup.examId":examId}, {"_id": 0,"examsGroup": 1}).toArray(function (err, result) {</span>

if (!err) { console.log(result); callback(result); } else { console.log(err); }

其中

user.find({"userName": userName,"examsGroup.examId":examId}....

useName：是定位到这个表的某一条数据，它可以查到如图中这样结构的一行数据，然后

examsGroup.examId：是定位到这一条数据它的examGroup，再通过examId定位到examsGroup中的某一对象

<span style="font-size:10px;">{"_id": 0,"examsGroup": 1}</span>

该语句控制只输出examsGroup中的内容

（3）删除内嵌文档examsGroup的某一对象数据

<span style="font-size:10px;">exports.deleteStudentExam =function(db,examId,callback) {
    var user = db.collection("student_exams");

    user.updateMany({"examsGroup.examId":examId},
        {$pull:{"examsGroup":{examId:examId}}},
        function(err, result) {
        if(!err) {
            callback(1)
        }
        else
            console.log(err);
    });
}</span>

因为不是删除表中的某条数据，所以用update来更新某条数据中的内容，这里用操作符$pull将对应examId的那个对象拉出取出来。删除方法很多，不止这个。

updateMany：当通过查询条件{"examsGroup.examId":examId}查询到很多条的时候，updateMany会应用于查出来的所有条

updateOne：只会应用于查出来的第一条

（4）向内嵌文档examsGroup中增加一个对象，即增加examsGroup下的0.1.2……

<span style="font-size:10px;">user.updateMany({},{"$push":{"examsGroup" : {
        "examId" : examId,
        "examName" : examName,
        "score" : -1,
        "resultGroup" : []
    }}},function(err, result) {
        if(!err) {

            callback(result);
        }
        else{
            console.log(err);
        }
    });</span>

$push：把一个对象插进内嵌文档当中，以下是它需要插入的属性，而且你每个对象插入的属性都可以不一样。

{"examsGroup" : {
        "examId" : examId,
        "examName" : examName,
        "score" : -1,
        "resultGroup" : []
    }}

（5）更新内嵌文档的score属性的值

   student.updateOne({"examsGroup.examId":examId,userName:userName},{"$set":{"examsGroup.$.score" :totalScore}},function(err, collection) {...

$set：用来更新属性和更新对象集合

{"$set":{"examsGroup.$.score" :totalScore}

需要这样定位到某examId下的score

（6）给内嵌文档resultGroup插入多个对象

student.updateOne({"examsGroup.examId":examId,userName:userName},{"$pushAll":{"examsGroup.$.resultGroup" :
                        resultGroups

                    }});

resultGroups：是一个对象数据，它存储的结构是：

[{"answer":["A"],"answerId":1,"isCorrect":false},{"answer":["B"],"answerId":2,"isCorrect":false},{"answer":["C"],"answerId":3,"isCorrect":false}]

$pushAll:可以一次插入多个value,这里直接把整个array插入

（7）两个表关联处理，虽然mongodb不推荐关联，但是对于我这种mongo初学的人来说，习惯了关系型数据库，设计表上还是存在关联的。

以下是Teacher表的数据结构：

array.databaseId：存储的是exam表中某一题目的id

以下是exam表结构：

如果需要将exam表的id和Teacher表的databaseId关联起来的话

user.find({"examId":Id}).toArray(function (err,result) {

        if(result.length!=0){

            var databaseIds = result[0];
            var idArray = new Array();
            for(var i=0;i<databaseIds.array.length;i++)
                idArray[i]=databaseIds.array[i].databaseId;
            ;
            var allTitle = db.collection("exam");
            allTitle.find({id: {$in: idArray}}, showOption).toArray(function (err, result) {
                if (!err) {

                    var sortResult = new Array();
                    for (var i = 0; i < idArray.length; i++) {
                        for (var j = 0; j < result.length; j++) {

                            if (idArray[i] == result[j].id) {
                                sortResult[i] = result[j];

                                break;
                            }
                        }
                    }
                    callback(sortResult);
                }
                else {
                    console.log(err);
                    callback({code: 404, status: "fail"});
                }

            });
        }
        else{
            callback({code:404, status:"fail"});
        }

    });

需要提到的点

1.find().toArray()方法搜出来是的一个以“[ ]”包围的json集合,如果你查出来的是一条数据，那么格式是：[{}]

如果是多条数据则是：[{},{}……]

当你查出来是一条数据或多条数据时，你想对某个对象操作的话：

var object = result[0];

（result是toArray回调的结果集）

然后你就可以通过object对里面的属性进行操作，如：

var databaseIds = result[0];
            var idArray = new Array();
            for(var i=0;i<databaseIds.array.length;i++)
                idArray[i]=databaseIds.array[i].databaseId;
            ;

把array里面的每一个对象的databaseId加到一个数组里面

 allTitle.find({id: {$in: idArray}}, showOption).toArray(function (err, result) {..

exam表里面查，如果id有存在在数组idArray里面的话，就符合

参考资源：

（1）mongodb：

like操作：http://blog.csdn.net/yuwenruli/article/details/8550864

操作符：http://www.jb51.net/article/48216.htm

nodejs+mongoAPI：http://mongodb.github.io/node-mongodb-native/2.0/api/Collection.html

mongodbAPI：

http://mongodb.github.io/node-mongodb-native/api-generated/db.html#dereference

https://docs.mongodb.org/manual/reference/method/cursor.sort/

https://github.com/mongodb/node-mongodb-native/tree/3.0

http://www.runoob.com/mongodb/mongodb-operators.html

（2）项目和demo

http://blog.csdn.net/zk437092645/article/details/9330931

http://www.cnblogs.com/owenChen/archive/2013/01/23/2872360.html

http://www.cnblogs.com/imwtr/p/4360341.html

http://www.toolmao.com/nodejs-express-ejs-mongodb-server

https://github.com/nswbmw/N-blog/wiki/_pages

（3）express

http://expressjs.com/zh/guide/routing.html

http://blog.jobbole.com/56121/

http://javascript.ruanyifeng.com/nodejs/express.html#

API:http://expressjs.com/api.html

(4)nodejs

API:http://nodeapi.ucdok.com/#/api/http.html