var ori = {};  //  地球上最原始的蛋白质，这就是一个对象

var c = {cell: 1};  //  单细胞动物

var chicken = { leg: 2, song: function () { alert('我是一只小小鸟'); } };

console.log(ori, c, chicken);

chicken.song(); //  我是一只小小鸟

chicken.wine = 2; // 增加2条翅膀
console.log(chicken.wine);

// 这只小鸡受到弹弓击打，不会唱歌了！
delete chicken.song;
console.log(chicken);

//require表示引包，引包就是引用自己的一个特殊功能
var http = require("http");
//创建服务器，参数是一个回调函数，表示如果有请求进来，要做什么
var server = http.createServer(function (req, res) {
    //req表示请求，request;  res表示响应，response
    //设置HTTP头部，状态码是200，文件类型是html，字符集是utf8
    res.writeHead(200, {"Content-type": "text/html;charset=UTF-8"});
    res.end("哈哈哈哈，我买了一个iPhone" + (1 + 2 + 3) + "s");
});

//运行服务器，监听3000端口（端口号可以任改）
server.listen(3000, "127.0.0.1");

//require表示引包，引包就是引用自己的一个特殊功能
var http = require("http");
var fs = require("fs");

//创建服务器，参数是一个回调函数，表示如果有请求进来，要做什么
var server = http.createServer(function (req, res) {
    if (req.url == "/fang") {
        fs.readFile("./test/xixi.html", function (err, data) {
            //req表示请求，request;  res表示响应，response
            //设置HTTP头部，状态码是200，文件类型是html，字符集是utf8
            res.writeHead(200, {"Content-type": "text/html;charset=UTF-8"});
            res.end(data);
        });
    } else if (req.url == "/yuan") {
        fs.readFile("./test/haha.html", function (err, data) {
            //req表示请求，request;  res表示响应，response
            //设置HTTP头部，状态码是200，文件类型是html，字符集是utf8
            res.writeHead(200, {"Content-type": "text/html;charset=UTF-8"});
            res.end(data);
        });
    } else if (req.url == "/0.jpg") {
        fs.readFile("./test/0.jpg", function (err, data) {
            //req表示请求，request;  res表示响应，response
            //设置HTTP头部，状态码是200，文件类型是html，字符集是utf8
            res.writeHead(200, {"Content-type": "image/jpg"});
            res.end(data);
        });
    } else if (req.url == "/bbbbbb.css") {
        fs.readFile("./test/aaaaaa.css", function (err, data) {
            //req表示请求，request;  res表示响应，response
            //设置HTTP头部，状态码是200，文件类型是html，字符集是utf8
            res.writeHead(200, {"Content-type": "text/css"});
            res.end(data);
        });
    } else {
        res.writeHead(404, {"Content-type": "text/html;charset=UTF-8"});
        res.end("嘻嘻，没有这个页面呦");
    }
});

//运行服务器，监听3000端口（端口号可以任改）
server.listen(3000, "127.0.0.1");

//这个案例简单讲解http模块
//引用模块
var http = require("http");

//创建一个服务器，回调函数表示接收到请求之后做的事情
var server = http.createServer(function (req, res) {
    //req参数表示请求，res表示响应
    console.log("服务器接收到了请求" + req.url);
    //设置头部
    res.writeHead(200, {"Content-Type": "text/html;charset=UTF8"});
    res.write("<h1>我是主标题</h1>");
    res.write("<h2>我是2标题</h2>");
    res.write("<h2>我是2标题</h2>");
    res.write("<h2>我是2标题</h2>");
    res.write("<h3>我是3标题</h3>");
    //必须添加end()方法，不然网页会一直处于加载而没法停止完成
    res.end((1 + 2 + 3).toString());
});

//监听端口
server.listen(3000, "127.0.0.1");

var http = require("http");

var server = http.createServer(function (req, res) {
    console.log(req.url); // 控制台中输出 "/"、"/favicon.ico"
    res.end();
});

server.listen(3000, "127.0.0.1");

var http = require("http");
var url = require("url");

var server = http.createServer(function (req, res) {
    //url.parse()可以将一个完整的URL地址，分为很多部分：
    //host、port、pathname、path、query
    var pathname = url.parse(req.url).pathname;
    //url.parse()如果第二个参数是true，那么就可以将所有的查询变为对象
    /*
     * 这里是通过 querystring 模块的 parse() 方法生成一个对象。
     * 如果为 false，则返回的 URL 对象上的 query 属性会是一个未解析、未解码的字符串。
     * 默认为 false。
     */
    //就可以直接打点得到这个参数
    var query1 = url.parse(req.url).query;
    var query2 = url.parse(req.url, true).query;
    //直接打点得到这个参数
    var age = query2.age;

    //访问http://localhost:3000/abc?name=auven&age=123
    console.log("pathname:" + pathname); // 输出/abc
    console.log("query1:" + query1); // 输出 name=auven&age=123
    // 这里的JSON.stringify()是讲对象转换为字符串，才能在控制台正常输出
    console.log("query2:" + JSON.stringify(query2)); // 输出 {"name":"auven","age":"123"}
    console.log("age:" + age); // 输出 123

    res.end();
});

server.listen(3000, "127.0.0.1");

// 当用户访问/student/1234567890 的查询此学号的学生信息。
// 当用户方位/teacher/645433 的时候，查询此老师的信息
// 其他的，我们提示错误。如果位数不对，也是提示位数不对

var http = require("http");

var server = http.createServer(function (req, res) {
    //得到url
    var userurl = req.url;

    res.writeHead(200, {"Content-Type": "text/html;charset=UTF8"})
    //substr函数来判断此时的开头
    if (userurl.substr(0, 9) == "/student/") {
        var studentid = userurl.substr(9);
        console.log(studentid);
        if (/^\d{10}$/.test(studentid)) {
            res.end("您要查询学生信息，id为" + studentid);
        } else {
            res.end("学生学号位数不对");
        }
    } else if (userurl.substr(0, 9) == "/teacher/") {
        var teacherid = userurl.substr(9);
        if (/^\d{6}$/.test(teacherid)) {
            res.end("您要查询老师信息，id为" + teacherid);
        } else {
            res.end("老师学号位数不对");
        }
    } else {
        res.end("请检查url");
    }
});

server.listen(3000, "127.0.0.1");

var http = require("http");
var fs = require("fs");

var server = http.createServer(function (req, res) {
    //不处理小图标
    if (req.url == "/favicon.ico") {
        return;
    }
    //给用户加一个五位数的id
    var userid = parseInt(Math.random() * 89999) + 10000;

    console.log("欢迎" + userid);

    res.writeHead(200, {"Content-Type": "text/html;charset=UTF8"});
    //两个参数，第一个是完整路径，当前目录写./
    //第二个参数，就是回调函数，表示文件读取成功之后，做的事情
    fs.readFile("./test/1.txt", function (err, data) {
        if (err) {
            throw err;
        }
        console.log(userid + "文件读取完毕");
        res.end(data);
    });

});

server.listen(3000);

var http = require("http");
var fs = require("fs");

var server = http.createServer(function (req, res) {
    //不处理小图标
    if (req.url == "/favicon.ico") {
        return;
    }
    fs.mkdir("./album/aaa");
    res.end("success");
});

server.listen(3000);

var http = require("http");
var fs = require("fs");

var server = http.createServer(function (req, res) {
    //不处理小图标
    if (req.url == "/favicon.ico") {
        return;
    }
    //stat检测状态，这个文件或文件夹必须存在，不然data.isDirectory()会报错
    fs.stat("./album/bbb", function (err, data) {
        //检测这个路径，是不是一个文件夹
        console.log(data.isDirectory());
    });
});

server.listen(3000, "127.0.0.1");

var http = require("http");
var fs = require("fs");

var server = http.createServer(function (req, res) {
    //不处理小图标
    if (req.url == "/favicon.ico") {
        return;
    }
    //存储所有的文件夹
    var wenjianjia = [];
    //stat检测状态
    fs.readdir("./album", function (err, files) {
        //files是个文件名的数组，并不是文件的数组，表示./album这个文件夹中的所有东西
        //包括文件、文件夹
        for (var i = 0; i < files.length; i++) {
            var thefilename = files[i];
            //又要进行一次检测
            fs.stat("./album/" + thefilename, function (err, stats) {
                //如果他是一个文件夹，那么输出它：
                if (stats.isDirectory()) {
                    wenjianjia.push(thefilename);
                }
                console.log(wenjianjia); // 输出为空数组，以及重复
            });
        }
    });
});

server.listen(3000, "127.0.0.1");

var http = require("http");
var fs = require("fs");

var server = http.createServer(function (req, res) {
    //不处理收藏夹小图标
    if (req.url == "/favicon.ico") {
        return;
    }
    //遍历album里面的所有文件、文件夹
    fs.readdir("./album/", function (err, files) {
        //files : ["0.jpg","1.jpg" ……,"aaa","bbb"];
        //files是一个存放文件(夹)名的数组
        //存放文件夹的数组
        var wenjianjia = [];
        //迭代器就是强行把异步的函数，变成同步的函数
        //1做完了，再做2；2做完了，再做3
        (function iterator(i) {
            //遍历结束
            if (i == files.length) {
                console.log(wenjianjia);
                return;
            }
            fs.stat("./album/" + files[i], function (err, stats) {
                //检测成功之后做的事情
                if (stats.isDirectory()) {
                    //如果是文件夹，那么放入数组。不是，什么也不做。
                    wenjianjia.push(files[i]);
                }
                iterator(i + 1);
            });
        })(0);
    });
    res.end();
});

server.listen(3000, "127.0.0.1");

var http = require("http");
var fs = require("fs");
var url = require("url");
var path = require("path");

var server = http.createServer(function(req,res){
    //这里如果不用req.url来if判断，那么用户不管输入什么网址，
    //做的事情都一样啊
    //得到地址
    var pathname = url.parse(req.url).pathname;
    //判断此时用户输入的地址是文件夹地址还是文件地址
    //如果是文件夹地址，那么自动请求这个文件夹中的index.html
    if(pathname.indexOf(".") == -1){
        pathname += "/index.html";
    }
    //输入的网址是127.0.0.1/images/logo.png
    //实际请求的是./static/images/logo.png
    var fileURL = "./" + path.normalize("./static/" + pathname);
    //得到拓展名
    var extname = path.extname(pathname);

    //把文件读出来
    fs.readFile(fileURL,function(err,data){
        //读完之后做的事情
        if(err){
            //文件不存在
            res.writeHead(404,{"Content-Type":"text/html;charset=UTF8"})
            res.end("404,页面没有找到");
        }
        //读完之后做的事情
        getMime(extname,function(mime){
            res.writeHead(200,{"Content-Type":mime})
            res.end(data);
        });
    });
});

server.listen(80,"127.0.0.1");

function getMime(extname,callback){
    //读取mime.json文件，得到JSON，根据extname key ，返回对应的value
    //读取文件
    fs.readFile("./mime.json",function(err,data){
        if(err){
            throw Error("找不到mime.json文件！");
            return;
        }
        //转成JSON
        var mimeJSON = JSON.parse(data);
        var mime =  mimeJSON[extname]  || "text/plain";
        //执行回调函数，mime类型字符串，就是它的参数
        callback(mime);
    });
}

var bar = require("./bar.js");
var msg = "你好";
var info = "呵呵";

function showInfo(){
    console.log(info);
}

exports.msg = msg;
exports.info = info;
exports.showInfo = showInfo;

var foo = require("./test/foo.js");

console.log(foo.msg);
console.log(foo.info);
foo.showInfo();

function People(name, sex, age) {
    this.name = name;
    this.sex = sex;
    this.age = age;
}

People.prototype = {
    sayHello: function () {
        console.log(this.name + this.sex + this.age);
    }
}

//此时，People就被视为构造函数，可以用new来实例化了。
module.exports = People;

var People = require("./test/People.js");
var xiaoming = new People("小明","男","12");
xiaoming.sayHello();

var foo = require("foo.js");  //没有写./

console.log(foo.msg);

{
  "name": "kaoladebar",
  "version": "1.0.1",
  "main" : "app.js"
}

var bar = require("bar");  //在引用一个文件夹

console.log(bar.msg);

exports.showIndex = showIndex;
exports.showStudent = showStudent;
exports.show404 = show404;

function showIndex(req, res) {
    res.writeHead(200, {"Content-Type": "text/html;charset=UTF8"});
    res.end("我是首页");
}

function showStudent(req, res) {
    var id = req.url.substr(9, 6);
    res.writeHead(200, {"Content-Type": "text/html;charset=UTF8"});
    res.end("我是学生页面" + id);
}

function show404(req, res) {
    res.writeHead(404, {"Content-Type": "text/html;charset=UTF8"});
    res.end("404");
}

var http = require("http");
var router = require("./router.js");

//创建服务器
var server = http.createServer(function (req, res) {
    if (req.url == "/") {
        router.showIndex(req, res);
    } else if (req.url.substr(0, 9) == "/student/") {
        router.showStudent(req, res);
    } else {
        router.show404(req, res);
    }
});

server.listen(80, "127.0.0.1");

var http = require("http");
var querystring = require("querystring");
var fs = require('fs');

/创建服务器
var server = http.createServer(function(req,res){
    //把文件读出来
    fs.readFile('./form.html',function(err,data){
        //读完之后做的事情
        if(err){
            //文件不存在
            res.writeHead(404,{"Content-Type":"text/html;charset=UTF8"})
            res.end("404,页面没有找到");
        }
        //读完之后做的事情
        res.end(data);
    });

    //如果你的访问地址是这个，并且请求类型是post
    if(req.url == "/dopost" && req.method.toLowerCase() == "post"){
        var alldata = "";
        //下面是post请求接收的一个公式
        //node为了追求极致，它是一个小段一个小段接收的。
        //接受了一小段，可能就给别人去服务了。防止一个过大的表单阻塞了整个进程
        req.addListener("data",function(chunk){
            alldata += chunk;
        });
        //全部传输完毕
        req.addListener("end",function(){
            var datastring = alldata.toString();
            res.end("success");
            //将datastring转为一个对象
            var dataObj = querystring.parse(datastring);
            console.log(req.headers);
            console.log(alldata);
            console.log(datastring);
            console.log(dataObj);
            console.log(dataObj.name);
            console.log(dataObj.sex);
            console.log(dataObj.hobby);
        });
    }
});

server.listen(3000,"127.0.0.1");

var http = require("http");
var formidable = require('formidable');
var util = require("util");
var fs = require('fs');


//创建服务器
var server = http.createServer(function (req, res) {

    //如果你的访问地址是这个，并且请求类型是post
    if (req.url == "/dopost" && req.method.toLowerCase() == "post") {
        //Creates a new incoming form.
        var form = new formidable.IncomingForm();
        //设置文件上传存放地址
        form.uploadDir = "./uploads";
        //执行里面的回调函数的时候，表单已经全部接收完毕了。
        form.parse(req, function (err, fields, files) {
            if (err) {
                throw err;
            }
            console.log(fields);
            console.log(files);
            console.log(util.inspect({fields: fields, files: files}));
            //所有的文本域、单选框，都在fields存放；
            //所有的文件域，files
            res.writeHead(200, {'content-type': 'text/plain;charset=UTF8'});

            res.end("成功");
        });
    } else if (req.url == "/") {
        //呈递form.html页面
        fs.readFile("./form1.html", function (err, data) {
            res.writeHead(200, {'content-type': 'text/html'});
            res.end(data);
        })
    } else {
        res.writeHead(404, {'content-type': 'text/html'});
        res.end("404");
    }

});

server.listen(3000, "127.0.0.1");

//console.log(fields);
{ name: '张剑', sex: '男', hobby: '足球' }

//console.log(files);
{ tupian:
   File {
     domain: null,
     _events: {},
     _eventsCount: 0,
     _maxListeners: undefined,
     size: 11983,
     path: 'uploads/upload_f77f8e5444e3b296006b76a4b35e2ffa',
     name: '2.jpg',
     type: 'image/jpeg',
     hash: null,
     lastModifiedDate: 2017-04-18T02:24:11.857Z,
     _writeStream:
      WriteStream {
        _writableState: [Object],
        writable: false,
        domain: null,
        _events: {},
        _eventsCount: 0,
        _maxListeners: undefined,
        path: 'uploads/upload_f77f8e5444e3b296006b76a4b35e2ffa',
        fd: null,
        flags: 'w',
        mode: 438,
        start: undefined,
        autoClose: true,
        pos: undefined,
        bytesWritten: 11983,
        closed: true } } }

//console.log(util.inspect({fields: fields, files: files}));
{ fields: { name: '张剑', sex: '男', hobby: '足球' },
  files:
   { tupian:
      File {
        domain: null,
        _events: {},
        _eventsCount: 0,
        _maxListeners: undefined,
        size: 11983,
        path: 'uploads/upload_f77f8e5444e3b296006b76a4b35e2ffa',
        name: '2.jpg',
        type: 'image/jpeg',
        hash: null,
        lastModifiedDate: 2017-04-18T02:24:11.857Z,
        _writeStream: [Object] } } }

path.extname('index.html')
// 返回: '.html'

path.extname('index.coffee.md')
// 返回: '.md'

path.extname('index.')
// 返回: '.'

path.extname('index')
// 返回: ''

path.extname('.index')
// 返回: ''

var ejs = require("ejs");

//模板
var string = "好高兴啊，今天我买了iphone<%= a %>s";
//数据
var data = {
    a : 6
};
//数据绑定
var html = ejs.render(string, data);
//输出
console.log(html);

var ejs = require("ejs");
var fs = require("fs");
var http = require("http");


var server = http.createServer(function (req, res) {
    fs.readFile("./views/index.ejs", function (err, data) {
        //绑定模板
        var template = data.toString();
        //传递参数
        var dictionary = {
            a: 6,
            news: [
                {"title": "陈伟我爱你", "count": 10},
                {"title": "哈哈哈哈", "count": 20},
                {"title": "逗你玩儿的", "count": 30}
            ]
        };
        var html = ejs.render(template, dictionary);

        //显示
        res.writeHead(200, {"Content-Type": "text/html;charset=UTF8"});
        res.end(html);
    });
});

server.listen(3000);

var express = require("express");

var app = express();

// 这里use之后，底下的所有路由都将失效，所有页面在这里就有加载完成，无法进入底下的路由
// app.use(function (req, res) {
//     res.send("123456789");
// });

app.get("/", function (req, res) {
    res.send("你好");
});

app.get("/haha", function (req, res) {
    res.send("这是haha页面，哈哈哈哈哈哈");
});

//无视大小写，? #
app.get("/AAb", function (req, res) {
    res.send("你好");
});

// 冒号
app.get("/student/:id", function (req, res) {
    var id = req.params["id"];
    var reg = /^[\d]{6}$/;
    if (reg.test(id)) {
        res.send(id);
    } else {
        res.send("请检查格式");
    }
});

//冒号
app.get("/:username/:oid", function (req, res) {
    var username = req.params["username"];
    var oid = req.params["oid"];

    res.write(username);
    res.end(oid);
});

app.listen(3000);

var express = require("express");

var app = express();

// 通过localhost:3000就可以访问到
app.use(express.static("./public"));

app.get("/haha", function (req, res) {
    res.send("haha ");
});

app.listen(3000);

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

// 设置模板引擎
app.set("view engine", "ejs");

// res.render中的'haha'，不指定路径时，默认从views文件夹中去寻找haha.ejs文件
app.get("/", function (req, res) {
    res.render("haha", {
        "news": ["我是小新闻啊", "我也是啊", "哈哈哈哈"]
    });
});

app.listen(3000);

var express = require("express");
var bodyParser = require('body-parser');

var app = express();


// parse application/x-www-form-urlencoded
app.use(bodyParser.urlencoded({extended: false}))

// parse application/json
app.use(bodyParser.json())

//设置模板引擎
app.set("view engine", "ejs");

app.get("/", function (req, res) {
    res.render("form");
});

app.post("/", function (req, res) {
    console.log(req.body); // { name: 'dfds', age: 'sgdfg' }
    //将数据添加进入数据库
    res.send("成功");
});

app.listen(3000);

var express = require("express");

var app = express();

app.get("/:username/:id", function (req, res, next) {
    // var username = req.params.username;
    // res.send("用户信息: " + username);

    next(); // 试着把next注释掉，把上面取消注释，访问/admin/login，看页面显示
});

// 这里的不会被执行，除非上面next()
app.get("/admin/login", function (req, res) {
    console.log("2");
    res.send("管理员登录");
});


app.listen(3000);

var express = require("express");

var app = express();

//当你不写路径的时候，实际上就相当于"/"，就是所有网址
app.use(function (req, res, next) {
    console.log(new Date());
    next();
});

app.get("/haha", function (req, res) {
    console.log("哈哈");
});

app.use("/admin", function (req, res) {
    // 设置返回的headers，'Content-Type'默认帮我们设置为utf8，我们可加可不加
    res.set({'aaa': 'utf8', 'Content-Type': 'text/plain'});
    // 访问http://localhost:3000/admin/login
    res.write(req.originalUrl + "\n"); // 输出/admin/login
    res.write(req.baseUrl + "\n"); // 输出/admin
    res.write(req.path + "\n"); // 输出/login
    res.end("你好");
});

app.listen(3000);

var express = require("express");
var fs = require("fs");

var app = express();

//当你不写路径的时候，实际上就相当于"/"，就是所有网址
app.use(haha);

app.get("/admin", function (req, res) {
    res.send("管理员");
})

app.listen(3000);

function haha(req, res, next) {
    var filePath = req.originalUrl;
    //根据当前的网址，读取public文件夹中的文件
    //如果有这个文件，那么渲染这个文件
    //如果没有这个文件，那么next();
    fs.readFile("./public/" + filePath, function (err, data) {
        if (err) {
            //文件不存在
            next();
            return;
        }
        res.send(data.toString());
    });
}

var express = require("express");

var app = express();

//静态服务
app.use("/jingtai", express.static("./public"));

//新的路由
app.get("/images", function (req, res) {
    res.send("哈哈");
});

//会自动识别err参数，如果有，那么就这个函数能捕获err
app.use(function (req, res) {
    res.status(404).send("没有这个页面！");
});

app.listen(3000);

var express = require("express");

var app = express();

app.get("/", function (req, res) {
    // 访问http://localhost:3000/?aa=123&bb=456&bb=789
    console.log(req.query); // 输出{ aa: '123', bb: [ '456', '789' ] }
    res.send();
});

app.listen(3000);

var express = require("express");
var app = express();
var MongoClient = require('mongodb').MongoClient;


app.get("/", function (req, res) {
    //url就是数据库的地址。/表示数据库
    //假如数据库不存在，没有关系，程序会帮你自动创建一个数据库
    var url = 'mongodb://localhost:27017/haha';
    //连接数据库
    MongoClient.connect(url, function (err, db) {
        //回调函数表示连接成功做的事情，db参数就是连接上的数据库实体
        if (err) {
            console.log("数据库连接失败");
            return;
        }
        console.log("数据库连接成功");
        //插入数据，集合如果不存在，也没有关系，程序会帮你创建
        db.collection('student').insertOne({
            "name": "哈哈",
            "age": parseInt(Math.random() * 100 + 10)
        }, function (err, result) {
            if (err) {
                console.log("插入失败");
                return;
            }
            //插入之后做的事情，result表示插入结果。
            //console.log(result);
            res.send(result);
            db.close();
        });
    });
});

app.listen(3000);

var express = require("express");
var MongoClient = require('mongodb').MongoClient;
var assert = require('assert');

var app = express();

app.set("view engine", "ejs");

//数据库连接的地址，最后的斜杠表示数据库名字
var shujukuURL = 'mongodb://localhost:27017/abc';

app.get("/", function (req, res) {
    //先连接数据库，对数据库的所有操作，都要写在他的回调函数里面。
    MongoClient.connect(shujukuURL, function (err, db) {
        if (err) {
            //res.write("数据库连接失败");
            return;
        }
        //res.write("恭喜，数据库已经成功连接 \n");
        //查询数据库，cursor游标，游标可以用each方法遍历
        //每次表示一条document
        var result = [];
        var cursor = db.collection('teacher').find();
        cursor.each(function (err, doc) {
            if (err) {
                //res.write("游标遍历错误");
                return;
            }
            if (doc !== null) {
                result.push(doc);
            } else {
                //console.log(result);
                //遍历完毕
                db.close();
                res.render("index", {
                    "result": result
                });
            }
        });
    });
});

app.get("/add", function (req, res) {
    res.render("add");
});

app.get("/tijiao", function (req, res) {

    //得到参数
    var name = req.query.name;
    var age = req.query.age;
    var yuwenchengji = req.query.yuwenchengji;
    var shuxuechengji = req.query.shuxuechengji;

    MongoClient.connect(shujukuURL, function (err, db) {
        if (err) {
            console.log("数据库连接失败");
            return;
        }

        db.collection("teacher").insertOne({
            "name": name,
            "age": age,
            "score": {
                "shuxue": shuxuechengji,
                "yuwen": yuwenchengji
            }
        }, function (err, result) {
            if (err) {
                console.log("数据库写入失败");
                return;
            }
            res.send("恭喜，数据已经成功插入");
            res.end();
            //关闭数据库
            db.close();
        });
    });
});

app.listen(3000);

//这个模块里面封装了所有对数据库的常用操作
var MongoClient = require('mongodb').MongoClient;
var settings = require("../settings.js");
//不管数据库什么操作，都是先连接数据库，所以我们可以把连接数据库
//封装成为内部函数
function _connectDB(callback) {
    var url = settings.dburl;   //从settings文件中，都数据库地址
    //连接数据库
    MongoClient.connect(url, function (err, db) {
        if (err) {
            callback(err, null);
            return;
        }
        callback(err, db);
    });
}

//插入数据
exports.insertOne = function (collectionName, json, callback) {
    _connectDB(function (err, db) {
        db.collection(collectionName).insertOne(json, function (err, result) {
            callback(err, result);
            db.close(); //关闭数据库
        })
    })
};

//查找数据，找到所有数据。args是个对象{"pageamount":10,"page":10}
exports.find = function (collectionName, json, C, D) {
    var result = [];    //结果数组
    if (arguments.length == 3) {
        //那么参数C就是callback，参数D没有传。
        var callback = C;
        var skipnumber = 0;
        //数目限制
        var limit = 0;
    } else if (arguments.length == 4) {
        var callback = D;
        var args = C;
        //应该省略的条数
        var skipnumber = args.pageamount * (args.page-1) || 0;
        //数目限制
        var limit = args.pageamount || 0;
        //排序方式
        var sort = args.sort || {};
    } else {
        throw new Error("find函数的参数个数，必须是3个，或者4个。");
        return;
    }

    //连接数据库，连接之后查找所有
    _connectDB(function (err, db) {
        var cursor = db.collection(collectionName).find(json).skip(skipnumber).limit(limit).sort(sort);
        cursor.each(function (err, doc) {
            if (err) {
                callback(err, null);
                db.close(); //关闭数据库
                return;
            }
            if (doc != null) {
                result.push(doc);   //放入结果数组
            } else {
                //遍历结束，没有更多的文档了
                callback(null, result);
                db.close(); //关闭数据库
            }
        });
    });
}

//删除
exports.deleteMany = function (collectionName, json, callback) {
    _connectDB(function (err, db) {
        //删除
        db.collection(collectionName).deleteMany(
            json,
            function (err, results) {
                callback(err, results);
                db.close(); //关闭数据库
            }
        );
    });
}

//修改
exports.updateMany = function (collectionName, json1, json2, callback) {
    _connectDB(function (err, db) {
        db.collection(collectionName).updateMany(
            json1,
            json2,
            function (err, results) {
                callback(err, results);
                db.close();
            });
    })
}

exports.getAllCount = function (collectionName, callback) {
    _connectDB(function (err, db) {
        db.collection(collectionName).count({}).then(function (count) {
            callback(count);
            db.close();
        });
    })
}

module.exports = {
    "dburl": "mongodb://localhost:27017/haha"
}

var express = require("express");
var app = express();
var db = require("./model/db.js");
var formidable = require('formidable');
var ObjectId = require('mongodb').ObjectID; // 可以将字符串转换为mongodb里的_id格式


//设置模板引擎
app.set("view engine", "ejs");

//静态
app.use(express.static("./public"));
//显示留言列表
app.get("/", function (req, res, next) {

    res.render("index");

});

app.get("/getAllPage", function (req, res, next) {
    db.getAllCount("liuyanben", function (count) {
        res.json({"result": Math.ceil(count / 5)})
    });
});

//读取所有留言，这个页面是供Ajax使用的
app.get("/du", function (req, res, next) {
    //可以接受一个参数
    var page = parseInt(req.query.page);

    db.find("liuyanben", {}, {"sort": {"shijian": -1}, "pageamount": 5, "page": page}, function (err, result) {
        // if(err){
        //     console.log('失败');
        // }
        // console.log(result);
        res.json({"result": result});
    });
});

//处理留言
app.post("/tijiao", function (req, res, next) {
    var form = new formidable.IncomingForm();

    form.parse(req, function (err, fields) {
        //写入数据库
        db.insertOne("liuyanben", {
            "xingming": fields.xingming,
            "liuyan": fields.liuyan,
            "shijian": new Date()
        }, function (err, result) {
            if (err) {
                res.send({"result": -1}); //-1是给Ajax看的
                return;
            }
            res.json({"result": 1});
        });
    });
});


//删除
app.get("/shanchu", function (req, res, next) {
    //得到参数
    var id = req.query.id;
    db.deleteMany("liuyanben", {"_id": ObjectId(id)}, function (err, result) {

        res.redirect("/");
    });
})

app.listen(3000);

var express  = require('express');
var cookieParser = require('cookie-parser');

var app = express();
//使用cookie必须要使用cookie-parser中间件
app.use(cookieParser());

var express = require('express');
var cookieParser = require('cookie-parser');

var app = express();
//使用cookie必须要使用cookie-parser中间件
app.use(cookieParser());

app.get("/", function (req, res) {
    res.send("猜你喜欢" + req.cookies.mudidi);
});

//查询一个地方的攻略，URL语法： http://127.0.0.1/gonglue?mudidi=北京
//此时北京就能记录在cookie中
app.get("/gonglue", function (req, res) {
    //得到get请求，用户查询的目的地
    var mudidi = req.query.mudidi;
    //console.log(mudidi);
    //记录用户喜好
    //先读取用户的喜好，然后把新的数据push进入数组，然后设置新的cookie
    var mudidiarry = req.cookies.mudidi || [];
    //console.log(mudidiarry);
    mudidiarry.push(mudidi);
    //maxAge在Express中以毫秒为单位
    res.cookie("mudidi", mudidiarry, {maxAge: 900000, httpOnly: true});
    res.send(mudidi + "旅游攻略");
});

app.listen(3000);

var express = require("express");
var app = express();
var session = require("express-session");

app.use(session({
    secret: 'keyboard cat',
    resave: false,
    saveUninitialized: true
}));

var express = require("express");
var app = express();
var session = require("express-session");

app.use(session({
    secret: 'keyboard cat',
    resave: false,
    saveUninitialized: true
}));

app.get("/", function (req, res) {
    if (req.session.login == "1") {
        res.send("欢迎" + req.session.username);
    } else {
        res.send("没有成功登陆");
    }
});

app.get("/login", function (req, res) {
    req.session.login = "1";	//设置这个session
    req.session.username = "考拉";
    res.send("你已经成功登陆");
});

app.listen(3000);

var md5 = crypto.createHash('md5');
var password = md5.update(fields.password).digest('base64');

var crypto = require("crypto");
module.exports = function(mingma){
    var md5 = crypto.createHash('md5');
    var password = md5.update(mingma).digest('base64');
    return password;
}

  var fs = require('fs');
  var gm = require('gm');

  gm('./danny.jpg')
      .resize(50, 50,"!")
      .write('./danny2.jpg', function (err) {
          if (err) {
              console.log(err);
          }
      });

gm("./danny.jpg").crop(141,96,152,181).write("./2.jpg",function(err){
     //141  96 是宽高 。  152  181是坐标
});

//引包，并不需要引用mongodb这个包
var mongoose = require('mongoose');
//链接数据库,haha是数据库名字
mongoose.connect('mongodb://localhost/haha');

//创建了一个模型。猫的模型。所有的猫，都有名字，是字符串。“类”。
var Cat = mongoose.model('Cat', { name: String });
//实例化一只猫
var kitty = new Cat({ name: 'Zildjian' });
//调用这只猫的save方法，保存这只猫
kitty.save(function (err) {
    console.log('喵喵喵');
});

var tom = new Cat({"name":"汤姆"});
tom.save(function(){
    console.log('喵喵喵');
});

var mongoose = require('mongoose');
//创建数据库连接
var db      = mongoose.createConnection('mongodb://127.0.0.1:27017/haha');
//监听open事件
db.once('open', function (callback) {
    console.log("数据库成功连接");
});