cookie
关于cookie
1.是什么？
本质就是一个字符串，里面包含着浏览器和服务器沟通的信息（交互时产生的信息）。
存储的形式以：key-value的形式存储。
浏览器会自动携带该网站的cookie，只要是该网站下的cookie，全部携带。
2.分类：
--会话cookie（关闭浏览器后，会话cookie会自动消失，会话cookie存储在浏览器运行的那块内存上）。
--持久化cookie：（看过期时间，一旦到了过期时间，自动销毁，存储在用户的硬盘上,备注：如果没有到过期时间，同时用户清理了缓存，持久化cookie也会消失）。
3.工作原理：（例子中的小纸条）
--当浏览器第一次请求服务器的时候，服务器可能返回一个或多个cookie给浏览器
--浏览器判断以下cookie种类
--会话cookie：存储在浏览器运行的那块内存上
--持久化cookie：存储在用户的硬盘上
--以后请求该网站的时候，自动携带上该网站的所有cookie（无法进行干预）
--服务器拿到之前自己“种”下cookie，分析里面的内容，校验cookie的合法性，根据cookie里保存的内容，进行具体的业务逻辑。
4.应用：
解决http无状态的问题（例子：7天免登录，一般来说不会单独使用cookie，一般配合后台的session存储使用）
5.不同的语言、不同的后端架构cookie的具体语法是不一样的，但是cookie原理和工作过程是不变的。
备注：cookie不一定只由服务器生成，前端同样可以生成cookie，但是前端生成的cookie几乎没有意义。
let express = require('express')
let cookieParser = require('cookie-parser')
let app = express()
app.disable('x-powered-by')
app.use(express.static('public'))
//使用cookie-parser，解析浏览器携带过来的cookie为为一个对象，随后挂载到request上
app.use(cookieParser())
//“种”cookie
app.get('/test1',(request,response)=>{
/*
* 当访问test1路由时会给客户端“种”一个cookie
* 在express中给客户端“种”一个cookie，不用借助任何第三方库
* */
//给客户端“种”下一个会话cookie
//response.cookie('demo',123)
//给客户端“种”下一个持久化cookie
response.cookie('demo',123,{maxAge:30 * 1000})
response.send('我给你种下了一个cookie，你快看看
')
})
//“读”cookie
app.get('/test2',(request,response)=>{
/*
* 当访问test2时，会获取到浏览器携带过来的cookie
* 在express中更方便的获取客户端携带过来的cookie，要借助一个中间件，名字：cookie-parser
* */
console.log(request.cookies)
const {demo} = request.cookies
console.log(demo)
response.send('我读到了你携带过来的cookies
')
})
//“删”cookie
app.get('/test3',(request,response)=>{
//第一种删除方式：
//response.cookie('demo','',{maxAge:0})
//第二种删除方式：
response.clearCookie('demo')
response.send('我删除了cookie')
})
//4.绑定端口监听
app.listen(3000,(err)=>{
if (!err) console.log('服务器启动成功了！')
else console.log(err)
})
登录注册（加入cookie）
db/index.js
/*
* 该模块用于连接数据库，暴露出去一个Promise实例
* 如果连接成功了，Promise实例内部状态切换为成功
* 如果连接失败了，Promise实例内部状态切换为失败
* */
//引入mongoose
let mongoose = require('mongoose')
mongoose.set('useCreateIndex',true)
//定义数据库名
const DB_NAME = 'test'
//定义数据库地址
const DB_URL = 'localhost:27017'
//构建一个Promise实例，用于管理数据库连接
module.exports = new Promise((resolve,reject)=>{
//2.连接数据库
mongoose.connect(`mongodb://${DB_URL}/${DB_NAME}`,{useNewUrlParser:true })
//3.监听连接状态
mongoose.connection.on('open',(err)=>{
if(!err){
console.log(`位于${DB_URL}上的${DB_NAME}数据库连接成功`)
resolve()
}else{
reject(err)
}
})
})
model/userModel.js
/*
* 该模块主要负责创建学生模型
* */
let mongoose = require('mongoose')
//操作数据库
//1.请来一个保安 ------- 引入约束Schema
let Schema = mongoose.Schema
//2.制定一个进入你家的规则 -------- 创建一个约束对象实例
let userSchema = new Schema({
email:{
type:String,
required:true,
unique:true
},
nick_name:{
type:String,
required:true,
},
password:{
type:String,
required:true,
},
date:{
type:Date,
default:Date.now()
},
enable_flag:{
type:String,
default:'Y'
}
})
/*3.告诉保安你的规则 ------- 创建模型对象
第一个参数与数据库中的集合相对应，第二个参数指定约束对象实例
只要生成了模型对象，就可以进行数据的：增删改查*/
module.exports = mongoose.model('users',userSchema)
router/businessRouter.js
/*
* 该模块是业务路由器，目前管理的业务有：登录、注册
* */
let {Router} = require('express')
//引入用户模型
let userModel = require('../model/userModel')
let router = new Router()
//业务路由----注册
router.post('/register',async(request,response)=>{
//1.获取用户的输入
const {email,nick_name,password,re_password} = request.body
//2.校验数据的合法性
//定义正则表达式
const emailReg = /^[a-zA-Z0-9_]{2,16}@[a-zA-Z0-9]{2,16}\.com$/
const nickNameReg = /[\u4e00-\u9fa5]/gm
const passwordReg = /^[a-zA-Z0-9_#]{6,16}$/
//定义一个收集错误信息的对象
const errMsg = {}
//使用正则进行校验
if(!emailReg.test(email)){
//response.send('邮箱输入不合法！要求邮箱用户名2-16位不包含特殊字符，邮箱主机名2-16位')
//return
errMsg.emailErr = '邮箱输入不合法！要求邮箱用户名2-16位不包含特殊字符，邮箱主机名2-16位'
}
if(!nickNameReg.test(nick_name)){
// response.send('昵称输入不合法，昵称应为中文')
// return
errMsg.nickNameErr = '昵称输入不合法，昵称应为中文'
}
if(!passwordReg.test(password)){
// response.send('密码输入不合法，密码应为6-16位字符不包含特殊字符')
// return
errMsg.passwordErr = '密码输入不合法，密码应为6-16位字符不包含特殊字符'
}
if(password !== re_password){
// response.send('两次输入密码不一致')
// return
errMsg.rePasswordErr = '两次输入密码不一致'
}
//判断错误对象是否为空
if(JSON.stringify(errMsg) !== '{}'){
//若果进入该判断，意味着用户输入的数据存在不合法的
response.render('register',{errMsg})
return
}
//try里面放可能出现错误的代码，一旦出现错误，会携带着错误信息来到catch中。
try{
//3.检查该邮箱是否注册过
let finResult = await userModel.findOne({email})
if(finResult){
//response.send(`注册失败，${email}邮箱已经被注册了`)
//return
errMsg.emailErr = `注册失败，${email}邮箱已经被注册了`
response.render('register',{errMsg})
}else{
await userModel.create({email,nick_name,password})
console.log(`邮箱为：${email}，昵称为:${nick_name}的用户注册成功了！`)
//response.send('注册成功了！')
response.redirect(`/login?email=${email}`)
}
}
catch(err){
//1.计数 2.引入警报模块
console.log(err)
errMsg.networkErr = `阿偶，网络不稳定，稍后重试！`
//response.send('阿偶，网络不稳定，稍后重试！')
response.render('register',{errMsg})
}
})
//业务路由 ---登录
router.post('/login',async(request,response)=>{
//1.获取用户的输入
const {email,password} = request.body
//定义正则表达式
const emailReg = /^[a-zA-Z0-9_]{2,16}@[a-zA-Z0-9]{2,16}\.com$/
const passwordReg = /^[a-zA-Z0-9_#]{6,16}$/
const errMsg = {}
//使用正则进行校验
if(!emailReg.test(email)){
//response.send('邮箱输入不合法！要求邮箱用户名2-16位不包含特殊字符，邮箱主机名2-16位')
//return
errMsg.emailErr = '邮箱输入不合法！要求邮箱用户名2-16位不包含特殊字符，邮箱主机名2-16位'
}
if(!passwordReg.test(password)){
// response.send('密码输入不合法，密码应为6-16位字符不包含特殊字符')
// return
errMsg.passwordErr = '密码输入不合法，密码应为6-16位字符不包含特殊字符'
}
//判断错误对象是否为空
if(JSON.stringify(errMsg) !== '{}'){
response.render('login',{errMsg})
return
}
try{
let findResult = await userModel.findOne({email,password})
if(findResult){
//response.redirect(`/usercenter?nick_name=${findResult.nick_name}`)
//response.render('usercenter',{nickName:findResult.nick_name})
//response.cookie('nick_name',findResult.nick_name,{maxAge:30 * 1000})
response.cookie('_id',findResult._id.toString(),{maxAge:30 * 1000})
response.redirect('/usercenter')
}else{
errMsg.loginErr = '登录失败，邮箱或密码输入错误！'
//response.send('登录失败，邮箱或密码输入错误！')
response.render('login',{errMsg})
}
}
catch(err){
console.log(err)
errMsg.networkErr = '阿偶，网络不稳定，稍后重试！'
//response.send('阿偶，网络不稳定，稍后重试！')
response.render('login',{errMsg})
}
})
module.exports = router
router/uiRouter.js
/*
* 该模块是UI路由器模块，用于管理UI路由，以后配置新页面，在这里定义路由即可
* */
let {Router} = require('express')
let cookieParser = require('cookie-parser')
//引入用户模型
let userModel = require('../model/userModel')
let router = new Router()
//引入path模块，path模块是node中的核心模块，无需下载，直接引入即可使用
let {resolve} = require('path')
router.use(cookieParser())
//UI路由--登录
router.get('/login',(request,response)=>{
//let filePath = resolve(__dirname,'../public/login.html')
//response.sendFile(filePath)
const {email} = request.query
response.render('login',{errMsg:{email}})
})
//UI路由--注册
router.get('/register',(request,response)=>{
//let filePath = resolve(__dirname,'../public/register.html')
//response.sendFile(filePath)
response.render('register',{errMsg:{}})
})
//UI路由--个人中心
router.get('/usercenter',async (request,response)=>{
const {_id} = request.cookies
if(_id){
let result = await userModel.findOne({_id})
if(result){
response.render('usercenter',{nickName:result.nick_name})
}else{
console.log('用户非法修改了cookie')
response.redirect('/login')
}
}else{
response.redirect('/login')
}
})
module.exports = router
views/login.ejs
登录页面
<%=errMsg.loginErr%>
<%=errMsg.networkErr%>
views/register.ejs
注册页面
<%=errMsg.networkErr%>
view/usercenter.ejs
个人中心
<%=nickName%>你好，欢迎访问您的个人中心
server.js
//引入express框架
let express = require('express')
//引入数据库连接模块
let db = require('./db')
//引入UI路由器
let uiRouter = require('./router/uiRouter')
//引入业务路由
let businessRouter = require('./router/businessRouter')
//创建app服务对象
let app = express()
//配置模板引擎
app.set("view engine" , "ejs");
//配置模板的存放目录
app.set("views","./views")
//数据库连接成功后，注册路由
db.then(()=>{
//使用内置中间件用于获取post请求体参数
app.use(express.urlencoded({extended:true}))
//使用UI路由器中间件
app.use(uiRouter)
//使用业务路由
app.use(businessRouter)
}).catch((err)=>{
console.log('数据库连接失败',err)
})
//绑定端口监听
app.listen(3000,(err)=>{
if (!err) console.log('服务器启动成功了！！')
else console.log(err)
})
session
关于session：
1.是什么？
标准来说，session指的是会话，但是后端人员常说的session，全称叫：服务器session会话存储。
2.特点：
1.存在于服务端
2.存储的是浏览器和服务器之间沟通产生的一些信息
3.默认session的存储在服务器的内存中，每当一个新客户端发来请求，服务器都会新开辟出一块空间，供session会话存储使用。
4.工作流程：
--第一次浏览器请求服务器的时候，服务器会开辟出一块内存空间，供session会话存储使用。
--返回响应的时候，会自动返回一个cookie（有时候会返回多个，为了安全），cookie里包含着，上一步产生会话存储“容器”的编号（id）
--以后请求的时候，会自动携带这个cookie，给服务器。
--服务器从该cookie中拿到对应的session的id，去服务器中匹配。
--服务器会根据匹配信息，决定下一步具体的业务逻辑。
5.备注：1.一般来说cookie一定会配合session使用。
2.服务端一般会做session的持久化，防止由于服务器重启，造成session的丢失。
步骤
1. 下载安装：npm i express-session --save 用于在express中操作session
2. 下载安装：npm i connect-mongo --save 用于将session写入数据库（session持久化）
3. 引入express-session模块：
const session = require('express-session')
4. 引入connect-mongo模块
const MongoStore = require('connect-mongo')('session')
5. 编写全局配置对象：
app.use(session({
name: 'userid', //设置cookie的name，默认值是：connect.sid
secret: 'atguigu', //参与加密的字符串（又称签名）
saveUninitialized: false, //是否存储内容之前创建会话
resave: true, //是否在每次请求时，强制重新保存session，即使他们没有变化
store: new MongoStore({
url: 'mongodb://localhost:27017/cookies_container',
touchAfter: 24 * 3600 //修改频率（例：//在24小时之内只更新一次）
}),
cookie: {
httpOnly: true, //开启后前端无法通过JS操作cookie
maxAge: 1000 * 30 //设置cookie的过期时间
}
}))
6. 向session中添加一个xxxx，值为yyy: require.session.xxxx = yyy
7. 获取session上的xxx属性: const {xxx} = req.session
整个过程是：
1.客户端第一次发起请求，服务器开启了一个session专门用于存储这次请求的一些信息。
2.根据配置对象的信息，服务器决定是否进行：session持久化等其他操作。
3.与此同时服务器创建一个cookie，它的key我们可以自己指定，但是它的value一定是上一步session的容器编号
4.等请求再次过来时，客户端的请求中包含着之前“种”的cookie
5.服务器检查携带过来的cookie是否有效，决定是否去读取对应session中的信息
登录注册（加入session）
db/index.js
/*
* 该模块用于连接数据库，暴露出去一个Promise实例
* 如果连接成功了，Promise实例内部状态切换为成功
* 如果连接失败了，Promise实例内部状态切换为失败
* */
//引入mongoose
let mongoose = require('mongoose')
mongoose.set('useCreateIndex',true)
//定义数据库名
const DB_NAME = 'test'
//定义数据库地址
const DB_URL = 'localhost:27017'
//构建一个Promise实例，用于管理数据库连接
module.exports = new Promise((resolve,reject)=>{
//2.连接数据库
mongoose.connect(`mongodb://${DB_URL}/${DB_NAME}`,{useNewUrlParser:true })
//3.监听连接状态
mongoose.connection.on('open',(err)=>{
if(!err){
console.log(`位于${DB_URL}上的${DB_NAME}数据库连接成功`)
resolve()
}else{
reject(err)
}
})
})
model/userModel.js
/*
* 该模块主要负责创建学生模型
* */
let mongoose = require('mongoose')
//操作数据库
//1.请来一个保安 ------- 引入约束Schema
let Schema = mongoose.Schema
//2.制定一个进入你家的规则 -------- 创建一个约束对象实例
let userSchema = new Schema({
email:{
type:String,
required:true,
unique:true
},
nick_name:{
type:String,
required:true,
},
password:{
type:String,
required:true,
},
date:{
type:Date,
default:Date.now()
},
enable_flag:{
type:String,
default:'Y'
}
})
/*3.告诉保安你的规则 ------- 创建模型对象
第一个参数与数据库中的集合相对应，第二个参数指定约束对象实例
只要生成了模型对象，就可以进行数据的：增删改查*/
module.exports = mongoose.model('users',userSchema)
router/businessRouter.js
/*
* 该模块是业务路由器，目前管理的业务有：登录、注册
* */
let {Router} = require('express')
//引入用户模型
let userModel = require('../model/userModel')
let router = new Router()
//业务路由----注册
router.post('/register',async(request,response)=>{
//1.获取用户的输入
const {email,nick_name,password,re_password} = request.body
//2.校验数据的合法性
//定义正则表达式
const emailReg = /^[a-zA-Z0-9_]{2,16}@[a-zA-Z0-9]{2,16}\.com$/
const nickNameReg = /[\u4e00-\u9fa5]/gm
const passwordReg = /^[a-zA-Z0-9_#]{6,16}$/
//定义一个收集错误信息的对象
const errMsg = {}
//使用正则进行校验
if(!emailReg.test(email)){
//response.send('邮箱输入不合法！要求邮箱用户名2-16位不包含特殊字符，邮箱主机名2-16位')
//return
errMsg.emailErr = '邮箱输入不合法！要求邮箱用户名2-16位不包含特殊字符，邮箱主机名2-16位'
}
if(!nickNameReg.test(nick_name)){
// response.send('昵称输入不合法，昵称应为中文')
// return
errMsg.nickNameErr = '昵称输入不合法，昵称应为中文'
}
if(!passwordReg.test(password)){
// response.send('密码输入不合法，密码应为6-16位字符不包含特殊字符')
// return
errMsg.passwordErr = '密码输入不合法，密码应为6-16位字符不包含特殊字符'
}
if(password !== re_password){
// response.send('两次输入密码不一致')
// return
errMsg.rePasswordErr = '两次输入密码不一致'
}
//判断错误对象是否为空
if(JSON.stringify(errMsg) !== '{}'){
//若果进入该判断，意味着用户输入的数据存在不合法的
response.render('register',{errMsg})
return
}
//try里面放可能出现错误的代码，一旦出现错误，会携带着错误信息来到catch中。
try{
//3.检查该邮箱是否注册过
let finResult = await userModel.findOne({email})
if(finResult){
//response.send(`注册失败，${email}邮箱已经被注册了`)
//return
errMsg.emailErr = `注册失败，${email}邮箱已经被注册了`
response.render('register',{errMsg})
}else{
await userModel.create({email,nick_name,password})
console.log(`邮箱为：${email}，昵称为:${nick_name}的用户注册成功了！`)
//response.send('注册成功了！')
response.redirect(`/login?email=${email}`)
}
}
catch(err){
//1.计数 2.引入警报模块
console.log(err)
errMsg.networkErr = `阿偶，网络不稳定，稍后重试！`
//response.send('阿偶，网络不稳定，稍后重试！')
response.render('register',{errMsg})
}
})
//业务路由 ---登录
router.post('/login',async(request,response)=>{
//1.获取用户的输入
const {email,password} = request.body
//定义正则表达式
const emailReg = /^[a-zA-Z0-9_]{2,16}@[a-zA-Z0-9]{2,16}\.com$/
const passwordReg = /^[a-zA-Z0-9_#]{6,16}$/
const errMsg = {}
//使用正则进行校验
if(!emailReg.test(email)){
//response.send('邮箱输入不合法！要求邮箱用户名2-16位不包含特殊字符，邮箱主机名2-16位')
//return
errMsg.emailErr = '邮箱输入不合法！要求邮箱用户名2-16位不包含特殊字符，邮箱主机名2-16位'
}
if(!passwordReg.test(password)){
// response.send('密码输入不合法，密码应为6-16位字符不包含特殊字符')
// return
errMsg.passwordErr = '密码输入不合法，密码应为6-16位字符不包含特殊字符'
}
//判断错误对象是否为空
if(JSON.stringify(errMsg) !== '{}'){
response.render('login',{errMsg})
return
}
try{
let findResult = await userModel.findOne({email,password})
if(findResult){
//1.在服务器中开辟一块内存，用于存储session
//2.将用户的id存入上一步产生的session中
//3.获取session的编号，放入一个cookie中
//4.将上一步的cookie返回给客户端
//以上四步可以通过一行代码搞定
request.session._id = findResult._id
response.redirect('/usercenter')
}else{
errMsg.loginErr = '登录失败，邮箱或密码输入错误！'
//response.send('登录失败，邮箱或密码输入错误！')
response.render('login',{errMsg})
}
}
catch(err){
console.log(err)
errMsg.networkErr = '阿偶，网络不稳定，稍后重试！'
//response.send('阿偶，网络不稳定，稍后重试！')
response.render('login',{errMsg})
}
})
module.exports = router
router/uiRouter.js
/*
* 该模块是UI路由器模块，用于管理UI路由，以后配置新页面，在这里定义路由即可
* */
let {Router} = require('express')
let cookieParser = require('cookie-parser')
//引入用户模型
let userModel = require('../model/userModel')
let router = new Router()
//引入path模块，path模块是node中的核心模块，无需下载，直接引入即可使用
let {resolve} = require('path')
router.use(cookieParser())
//UI路由--登录
router.get('/login',(request,response)=>{
//let filePath = resolve(__dirname,'../public/login.html')
//response.sendFile(filePath)
const {email} = request.query
response.render('login',{errMsg:{email}})
})
//UI路由--注册
router.get('/register',(request,response)=>{
//let filePath = resolve(__dirname,'../public/register.html')
//response.sendFile(filePath)
response.render('register',{errMsg:{}})
})
//UI路由--个人中心
router.get('/usercenter',async (request,response)=>{
//1.获取cookie，读取cookie中session容器编号
//2.去服务器中匹配该编号对应的session容器
//3.根据匹配结果，进行具体的业务逻辑
const {_id} = request.session
if(_id){
let result = await userModel.findOne({_id})
if(result){
response.render('usercenter',{nickName:result.nick_name})
}else{
console.log('用户非法修改了cookie')
response.redirect('/login')
}
}else{
response.redirect('/login')
}
})
module.exports = router
views/login.ejs
登录页面
<%=errMsg.loginErr%>
<%=errMsg.networkErr%>
views/register.ejs
注册页面
<%=errMsg.networkErr%>
views/usercenter.ejs
个人中心
<%=nickName%>你好，欢迎访问您的个人中心
server.js
//引入express框架
let express = require('express')
//引入数据库连接模块
let db = require('./db')
//引入UI路由器
let uiRouter = require('./router/uiRouter')
//引入业务路由
let businessRouter = require('./router/businessRouter')
//引入express-session用于在express中操作session
let session = require('express-session');
//引入connect-mongo用于session持久化
const MongoStore = require('connect-mongo')(session);
//创建app服务对象
let app = express()
//配置模板引擎
app.set("view engine" , "ejs");
//配置模板的存放目录
app.set("views","./views")
//定义一个cookie和session组合使用的配置对象
app.use(session({
name: 'haha', //设置cookie的name，默认值是：connect.sid
secret: 'atguigu', //参与加密的字符串（又称签名）
saveUninitialized: false, //是否在存储内容之前创建会话
resave: true ,//是否在每次请求时，强制重新保存session，即使他们没有变化
store: new MongoStore({
url: 'mongodb://localhost:27017/cookies_container',
touchAfter: 1800//修改频率（例：//在24小时之内只更新一次）
}),
cookie: {
httpOnly: true, // 开启后前端无法通过 JS 操作cookie
maxAge: 1000*30 // 设置cookie的过期时间
},
}));
//数据库连接成功后，注册路由
db.then(()=>{
//使用内置中间件用于获取post请求体参数
app.use(express.urlencoded({extended:true}))
//使用UI路由器中间件
app.use(uiRouter)
//使用业务路由
app.use(businessRouter)
}).catch((err)=>{
console.log('数据库连接失败',err)
})
//绑定端口监听
app.listen(3000,(err)=>{
if (!err) console.log('服务器启动成功了！！')
else console.log(err)
})
sha1加密和md5加密
/*
* 该模块是业务路由器，目前管理的业务有：登录、注册
* */
let {Router} = require('express')
//引入用户模型
let userModel = require('../model/userModel')
//引入sha1加密
let sha1 = require('sha1')
let router = new Router()
//业务路由----注册
router.post('/register',async(request,response)=>{
//1.获取用户的输入
const {email,nick_name,password,re_password} = request.body
//2.校验数据的合法性
//定义正则表达式
const emailReg = /^[a-zA-Z0-9_]{2,16}@[a-zA-Z0-9]{2,16}\.com$/
const nickNameReg = /[\u4e00-\u9fa5]/gm
const passwordReg = /^[a-zA-Z0-9_#]{6,16}$/
//定义一个收集错误信息的对象
const errMsg = {}
//使用正则进行校验
if(!emailReg.test(email)){
//response.send('邮箱输入不合法！要求邮箱用户名2-16位不包含特殊字符，邮箱主机名2-16位')
//return
errMsg.emailErr = '邮箱输入不合法！要求邮箱用户名2-16位不包含特殊字符，邮箱主机名2-16位'
}
if(!nickNameReg.test(nick_name)){
// response.send('昵称输入不合法，昵称应为中文')
// return
errMsg.nickNameErr = '昵称输入不合法，昵称应为中文'
}
if(!passwordReg.test(password)){
// response.send('密码输入不合法，密码应为6-16位字符不包含特殊字符')
// return
errMsg.passwordErr = '密码输入不合法，密码应为6-16位字符不包含特殊字符'
}
if(password !== re_password){
// response.send('两次输入密码不一致')
// return
errMsg.rePasswordErr = '两次输入密码不一致'
}
//判断错误对象是否为空
if(JSON.stringify(errMsg) !== '{}'){
//若果进入该判断，意味着用户输入的数据存在不合法的
response.render('register',{errMsg})
return
}
//try里面放可能出现错误的代码，一旦出现错误，会携带着错误信息来到catch中。
try{
//3.检查该邮箱是否注册过
let finResult = await userModel.findOne({email})
if(finResult){
//response.send(`注册失败，${email}邮箱已经被注册了`)
//return
errMsg.emailErr = `注册失败，${email}邮箱已经被注册了`
response.render('register',{errMsg})
}else{
await userModel.create({email,nick_name,password:sha1(password)})
console.log(`邮箱为：${email}，昵称为:${nick_name}的用户注册成功了！`)
//response.send('注册成功了！')
response.redirect(`/login?email=${email}`)
}
}
catch(err){
//1.计数 2.引入警报模块
console.log(err)
errMsg.networkErr = `阿偶，网络不稳定，稍后重试！`
//response.send('阿偶，网络不稳定，稍后重试！')
response.render('register',{errMsg})
}
})
//业务路由 ---登录
router.post('/login',async(request,response)=>{
//1.获取用户的输入
const {email,password} = request.body
//定义正则表达式
const emailReg = /^[a-zA-Z0-9_]{2,16}@[a-zA-Z0-9]{2,16}\.com$/
const passwordReg = /^[a-zA-Z0-9_#]{6,16}$/
const errMsg = {}
//使用正则进行校验
if(!emailReg.test(email)){
//response.send('邮箱输入不合法！要求邮箱用户名2-16位不包含特殊字符，邮箱主机名2-16位')
//return
errMsg.emailErr = '邮箱输入不合法！要求邮箱用户名2-16位不包含特殊字符，邮箱主机名2-16位'
}
if(!passwordReg.test(password)){
// response.send('密码输入不合法，密码应为6-16位字符不包含特殊字符')
// return
errMsg.passwordErr = '密码输入不合法，密码应为6-16位字符不包含特殊字符'
}
//判断错误对象是否为空
if(JSON.stringify(errMsg) !== '{}'){
response.render('login',{errMsg})
return
}
try{
let findResult = await userModel.findOne({email,password:sha1(password)})
if(findResult){
//1.在服务器中开辟一块内存，用于存储session
//2.将用户的id存入上一步产生的session中
//3.获取session的编号，放入一个cookie中
//4.将上一步的cookie返回给客户端
//以上四步可以通过一行代码搞定
request.session._id = findResult._id
response.redirect('/usercenter')
}else{
errMsg.loginErr = '登录失败，邮箱或密码输入错误！'
//response.send('登录失败，邮箱或密码输入错误！')
response.render('login',{errMsg})
}
}
catch(err){
console.log(err)
errMsg.networkErr = '阿偶，网络不稳定，稍后重试！'
//response.send('阿偶，网络不稳定，稍后重试！')
response.render('login',{errMsg})
}
})
module.exports = router
/*
* 该模块是业务路由器，目前管理的业务有：登录、注册
* */
let {Router} = require('express')
//引入用户模型
let userModel = require('../model/userModel')
//引入sha1加密
let md5 = require('md5')
let router = new Router()
//业务路由----注册
router.post('/register',async(request,response)=>{
//1.获取用户的输入
const {email,nick_name,password,re_password} = request.body
//2.校验数据的合法性
//定义正则表达式
const emailReg = /^[a-zA-Z0-9_]{2,16}@[a-zA-Z0-9]{2,16}\.com$/
const nickNameReg = /[\u4e00-\u9fa5]/gm
const passwordReg = /^[a-zA-Z0-9_#]{6,16}$/
//定义一个收集错误信息的对象
const errMsg = {}
//使用正则进行校验
if(!emailReg.test(email)){
//response.send('邮箱输入不合法！要求邮箱用户名2-16位不包含特殊字符，邮箱主机名2-16位')
//return
errMsg.emailErr = '邮箱输入不合法！要求邮箱用户名2-16位不包含特殊字符，邮箱主机名2-16位'
}
if(!nickNameReg.test(nick_name)){
// response.send('昵称输入不合法，昵称应为中文')
// return
errMsg.nickNameErr = '昵称输入不合法，昵称应为中文'
}
if(!passwordReg.test(password)){
// response.send('密码输入不合法，密码应为6-16位字符不包含特殊字符')
// return
errMsg.passwordErr = '密码输入不合法，密码应为6-16位字符不包含特殊字符'
}
if(password !== re_password){
// response.send('两次输入密码不一致')
// return
errMsg.rePasswordErr = '两次输入密码不一致'
}
//判断错误对象是否为空
if(JSON.stringify(errMsg) !== '{}'){
//若果进入该判断，意味着用户输入的数据存在不合法的
response.render('register',{errMsg})
return
}
//try里面放可能出现错误的代码，一旦出现错误，会携带着错误信息来到catch中。
try{
//3.检查该邮箱是否注册过
let finResult = await userModel.findOne({email})
if(finResult){
//response.send(`注册失败，${email}邮箱已经被注册了`)
//return
errMsg.emailErr = `注册失败，${email}邮箱已经被注册了`
response.render('register',{errMsg})
}else{
await userModel.create({email,nick_name,password:md5(password)})
console.log(`邮箱为：${email}，昵称为:${nick_name}的用户注册成功了！`)
//response.send('注册成功了！')
response.redirect(`/login?email=${email}`)
}
}
catch(err){
//1.计数 2.引入警报模块
console.log(err)
errMsg.networkErr = `阿偶，网络不稳定，稍后重试！`
//response.send('阿偶，网络不稳定，稍后重试！')
response.render('register',{errMsg})
}
})
//业务路由 ---登录
router.post('/login',async(request,response)=>{
//1.获取用户的输入
const {email,password} = request.body
//定义正则表达式
const emailReg = /^[a-zA-Z0-9_]{2,16}@[a-zA-Z0-9]{2,16}\.com$/
const passwordReg = /^[a-zA-Z0-9_#]{6,16}$/
const errMsg = {}
//使用正则进行校验
if(!emailReg.test(email)){
//response.send('邮箱输入不合法！要求邮箱用户名2-16位不包含特殊字符，邮箱主机名2-16位')
//return
errMsg.emailErr = '邮箱输入不合法！要求邮箱用户名2-16位不包含特殊字符，邮箱主机名2-16位'
}
if(!passwordReg.test(password)){
// response.send('密码输入不合法，密码应为6-16位字符不包含特殊字符')
// return
errMsg.passwordErr = '密码输入不合法，密码应为6-16位字符不包含特殊字符'
}
//判断错误对象是否为空
if(JSON.stringify(errMsg) !== '{}'){
response.render('login',{errMsg})
return
}
try{
let findResult = await userModel.findOne({email,password:md5(password)})
if(findResult){
//1.在服务器中开辟一块内存，用于存储session
//2.将用户的id存入上一步产生的session中
//3.获取session的编号，放入一个cookie中
//4.将上一步的cookie返回给客户端
//以上四步可以通过一行代码搞定
request.session._id = findResult._id
response.redirect('/usercenter')
}else{
errMsg.loginErr = '登录失败，邮箱或密码输入错误！'
//response.send('登录失败，邮箱或密码输入错误！')
response.render('login',{errMsg})
}
}
catch(err){
console.log(err)
errMsg.networkErr = '阿偶，网络不稳定，稍后重试！'
//response.send('阿偶，网络不稳定，稍后重试！')
response.render('login',{errMsg})
}
})
module.exports = router