NodeJS05

• 回调函数：需要得到一个函数内部异步操作的结果

//    setTimeout
//    readFile
//    writeFile
//    ajax

function add(x, y, callback) {
	// callback 就是回调函数
	// var x = 10
	// var y = 20
	// var callback = function(ret){console.log(ret)}
  console.log(1)
  setTimeout(function () {
    var ret = x + y
    callback(ret)
  }, 1000)
}

add(10, 20, function (ret) {
  console.log(ret)
})

• 关系型数据库和非关系型数据库：

表就是关系 或者说 是 表与表之间存在关系

所有的关系型数据库：

1.通过 sql语言来操作 

2.在操作之前都需要设计表结构

3.数据表还支持约束： 唯一  / 主键 / 默认值 / 非空

非关系型数据库： 有的非关系型数据库就是 key-value键值对 没有表的概念

MongoDB 不需要设计表结构 可以任意的往数据库里存储数据 没有结构性的概念

• MongoDB数据库

确认mongodb安装成功：在cmd输入 mongbd --version 如果能正确返回mongodb版本号 说明安装成功

有多个数据库 每个数据库中有多个集合 集合中有多个文档 文档结构没有任何限制

集合是数组 集合中存文档 文档是对象

启动和关闭数据库：

1.启动

cmd直接输入mongod 启动数据库

但是mongobd默认使用 mongbd 命令所处盘符根目录下（c盘）的data/bd 目录作为自己的数据存储目录 如果没有该目录 则无法启动数据库

所以在第一次执行启动数据库命令前 要创建db目录 C:\data\db

如果想要修改默认的数据存储路径  mongod --dbpath = 路径

2.关闭

关闭：ctrl + C 即可关闭

3.连接数据库

cmd命令： mongo （默认连接本地数据库）

4.退出数据库

在连接状态输入exit 退出

5.基本命令

show dbs 查看所有数据库

db 查看当前操作的数据库 默认是test

use 数据库名 切换到指定数据库 如果该数据库不存在 则新建该数据库 

db.集合名.insert({}) 向该集合中添加数据

db.集合名.find() 查看该集合的所有数据

• 在node中操作mongodb

• 起步：

var mongoose = require('mongoose') //引入mongoose包

mongoose.connect('mongodb://localhost/test', { useMongoClient: true }); //连接数据库

var Cat = mongoose.model('Cat', { name: String });//创建模型 === 设计数据库

var kitty = new Cat({name:'kitty'}) 

kitty.save(function(err){
	if(err){
		console.log('err')
	}
	console.log('success')
})

• 增删改查基本操作：

var mongoose = require('mongoose') //1.引入第三方包
var Schema = mongoose.Schema //2.mongoose架构

//3.连接本地数据库 test1不需要提前创建 如果不存在 会在向该数据库中插入第一条记录后自动创建
mongoose.connect('mongodb://localhost/test1')

//4.创建文档结构
var userSchema = new Schema({
	username: {
		type: String, //指定数据类型
		required: true //必须有
	},
	password: {
		type: String,
		required: true
	},
	email: {
		type: String
	}
})

//5.将文档结构发布为模型 
/* mongoose.model 用来将架构发布成model
 *  第一个参数： 使用首字母大写的单词来定义要使用该架构的集合名 mongoose会自动将其转成 小写复数 的形式
 *  第二个参数： 已经定义好的架构名
 *  返回值： 模型构造函数 使用函数 实现对文档的增删改查
 */
var user = mongoose.model('User', userSchema)

//6.增加数据
// var user1 = new user({
// 	username:'jiaody1',
// 	password:'123',
// 	email:'jiaody123'
// })
// user1.save(function(err,result){
// 	if(err){
// 		console.log(err)
// 	}
// 	console.log(result)
// })

//7.查询数据 find 可以根据指定条件查询 可以查询到所有文档 即使只有一条记录 result也会返回数组 []
// findOne 查询一条记录 返回对象 {} 查询不到 返回null
// user.findOne({
// 	name: 'kitty'
// }, function(err, result) {
// 	if (err) {
// 		console.log(err)
// 	}
// 	console.log(result)
// })

//8.删除数据
// remove 根据条件删除所有
// findOneAndRemove (conditions,[options],[callback]) 根据条件删除一个
// findByIdAndRemove (id,[options],[callback]) 根据id删除一个
// user.remove({
// 	username: 'jiaody'
// }, function(err, result) {
// 	if (err) {
// 		console.log(err)
// 	}
// 	console.log(result)
// })

//9.更新数据
// update 根据条件更新所有
// findOneAndUpdate (conditions,[options],[callback]) 根据条件更新一个
// findByIdAndUpdate (id,[options],[callback]) 根据id更新一个
user.findByIdAndUpdate('5a001b23d219eb00c8581184', {
  password: '123456'
}, function (err,result) {
  if (err) {
    console.log(err)
  } else {
    console.log(result)
  }
})

• 使用mongo修改学生信息增删改查练习： 

//stu-mongo.js
var mongoose = require('mongoose') //引入mongoose第三方包

mongoose.connect('mongodb://localhost/stu') //连接mongo数据库

var Schema = mongoose.Schema //架构

var stuSchema = new Schema({
	name:{
		type:String,
		required:true
	},
	gender:{
		type:Number,
		enum:[0,1],
		required:true
	},
	age:{
		type:Number
	},
	hobbies:{
		type:String
	}
})

//var stu = mongoose.model('Student',stuSchema)

// var stu1 = new stu({
// 	name:'jiaody',
// 	gender:0,
// 	age:23,
// 	hobbies:'coding'
// })
// stu1.save(function(err,result){
// 	if(err){
// 		console.log(err)
// 	}
// 	console.log(result)
// })

module.exports =mongoose.model('Student',stuSchema)

//route.js

var fs = require('fs')
var express = require('express')
var router = express.Router() //创建express的路由容器
var stu = require('./stu-mongo')

/*
 * 渲染获取学生信息列表
 */
router.get('/students', function(req, res) {
	// stu.getInfo(function(err,students){
	// 	if(err){
	// 		return res.status(500).send('server error')
	// 	}
	// 	res.render('index.html',{
	// 		students:students
	// 	})
	// })
	stu.find(function(err, result) {
		if (err) {
			return res.status(500).send('server error')
		}
		res.render('index.html', {
			students: result
		})
		console.log(result)
	})
})

//渲染添加学生页面 get
router.get('/students/new', function(req, res) {
	res.render('new.html')
})

// 添加学生 post
router.post('/students/new', function(req, res) {
	/*
	 * 读取数据 req.body （字符串格式） --> 转成对象 --> 在对象中push该条数据 --> 把对象转成字符串 --> 再次写入文件
	 */
	// stu.addInfo(req.body,function(err){
	//  if(err){
	//   return res.status(500).send('error')
	//  }
	//  res.redirect('/students')
	// })	
	new stu(req.body).save(function(err) {
		if (err) {
			return res.status(500).send('server error')
		}
		res.redirect('/students')
	})
})

/*渲染编辑学生信息页面 需要获取要编辑的学生id 然后使用模板渲染编辑页面
 * id 信息保存在 req.query.id 中
 */
router.get('/students/edit',function(req,res){
	stu.findById(req.query.id.replace(/"/g,''),function(err,student){
		if(err){
			return res.status(500).send('server error')
		}
		//使用模板渲染edit.html 页面 传数据
		res.render('edit.html',{
			student:student
		})
	})
})

/*
 * 渲染编辑页面 post
 * 先获取提交的表单数据 req.body 然后更新表单
 */
router.post('/students/edit',function(req,res){
	// stu.updateInfo(req.body,function(err){
	// 	if(err){
	// 		return res.status(500).send('Server error.')
	// 	}
	// 	res.redirect('/students')
	// })
	stu.findByIdAndUpdate(req.body.id.replace(/"/g,''),req.body,function(err){
		if(err){
			return res.status(500).send('server error')
		}
		res.redirect('/students/')
	})
})

/*
 * 根据id删除信息 
 */
router.get('/students/delete',function(req,res){
	// stu.delInfo(req.query.id,function(err){
	// 	if(err)
	// 	{
	// 		return res.status(500).send('Server error.')
	// 	}
	// 	res.redirect('/students')
	// })
	stu.findByIdAndRemove(req.query.id.replace(/"/g,''),function(err){
		if(err){
			return res.status(500).send('server error')
		}
		res.redirect('/students')
	})
})

module.exports = router

• Promise：

• 1.Promise基本语法 

var fs = require('fs')

//Promise 是一个构造函数  Promise容器一旦创建 就立即执行里面的代码
//Promise不是异步 Promise中执行的任务一般是异步

var P1 = new Promise(function(resolve, reject) {
	fs.readFile('./a.txt', 'utf8', function(err, data) {
		if (err) {
			reject(err)
		} else {
			resolve(data)
		}
	})
})

var P2 = new Promise(function(resolve, reject) {
	fs.readFile('./b.txt', 'utf8', function(err, data) {
		if (err) {
			reject(err)
		} else {
			resolve(data)
		}
	})
})

var P3 = new Promise(function(resolve, reject) {
	fs.readFile('./c.txt', 'utf8', function(err, data) {
		if (err) {
			reject(err)
		} else {
			resolve(data)
		}
	})
})

P1.
then(function(data) {
	// then 方法中接收的 第一个function 就是容器中的 resolve 函数 
	// function 中接收的参数data 就是resolve接收的参数
	console.log(data)
	return P2
	/* return 中接收到的参数 会在下一个 then 中的 第一个function 作为参数被接收 
	*  没有return  后面接收到的就是 undefined
	*  如果return的是一个Promise对象 则下一个then中第一个function 就是该Promise对象的resolve函数
	*/ 
},function(err){
	// then 方法中接收的 第二个function 就是容器中的 reject 函数 
	// function 中接收的参数err 就是 reject 接收的参数
	console.log(err)
})
.then(function(data){
	console.log(data)
	return P3
})
.then(function(data){
	console.log(data)
})

• 2.封装readFile 

var fs = require('fs')

function pReadFile(filePath) {
	return new Promise(function(resolve,reject){
		fs.readFile(filePath, 'utf8', function(err, data) {
			if (err) {
				reject(err)
			} else {
				resolve(data)
			}
		})
	})
}

pReadFile('./a.txt')
.then(function(data){
	console.log(data)
	return pReadFile('./b.txt')
})
.then(function(data){
	console.log(data)
	return pReadFile('./c.txt')
})
.then(function(data){
	console.log(data)
})