文章目录
初始 Node.js
1. Node.js 简介
Node.js 是一个基于 Chrome V8 引擎的 JavaScript 运行环境。
Node.js 的官网地址: https://nodejs.org/zh-cn/
2. Node.js 环境安装
如果希望通过 Node.js 来运行 Javascript 代码,则必须在计算机上安装 Node.js 环境才行。
安装包可以从 Node.js 的官网首页直接下载,进入到 Node.js 的官网首页(https://nodejs.org/en/),点击
绿色的按钮,下载所需的版本后,双击直接安装即可。
打开终端,在终端输入命令 node –v 后,按下回车键,出现 Node.js 的版本号,即安装成功了
3. 在 Node.js 环境中执行 JavaScript 代码
node 文件路径
内置模块
fs 文件系统模块
fs 模块是官方提供的操作文件的模块
1. fs.readFile
fs.readFile() 用来 读取
指定文件中内容
格式:
fs.readFile(file[,options],callback(err,dataStr))
file: 文件路径
options(可选): 读取文件编码格式,默认utf8
callback: 回调函数, err.message 错误信息, dataStr 文件内容
示例:
#导入模块
const fs = require('fs')
#读取文件
fs.readFile(__dirname+'1.txt','utf8',function(err,dataStr){
if(err){
return console.log('文件读取失败:'+err.message)
}
console.log('文件读取成功,内容是:'+dataStr)
})
2. fs.writeFile
fs.writeFile() 用来向指定文件 写入内容
fs.writeFile() 可以创建写入文件,但不能创建路径
格式:
fs.writeFile(file,data[,options],callback(err){})
file:文件路径
data:写入内容
options(可选):写入格式,默认utf8
callback:回调函数,err.message 错误信息,
示例:
// 导入模块
const fs = require('fs')
// 写入文件
// __dirname 为当前文件所在目录
fs.writeFile(__dirname+'2.txt','hello Node.js!',function(err){
if(err){
return console.log('文件写入失败!'+err.message)
}
console.log('文件写入成功!')
})
path 路径模块
path 模块是官方提供的,处理路径的模块
1. path.join
path.join() 用来进行路由拼接
格式:
path.jion(...paths)
示例:
const path = require('path')
const pathStr01 = path.join('/a','../','c')
console.log(pathStr01) // 输出 \c
const pathStr2 = path.join(__dirname,'./files/1.txt')
console.log(pathStr02) // 1.txt文件完成目录
涉及到路径拼接,都要使用 path.join(__dirname,'...')
提高可移植性
2. path.basename
path.basename() 在路径中获取文件名
格式:
path.basename(path[,ext])
path: 路径字符串
ext(可选): 文件扩展名
示例:
// 导入模块
const path = require('path')
const fpath = '/a/b/c/index.html'
var text01 = path.basename(fpath)
console.log(text01) // 输出 index.html
var text02= path.basename(fpath,'.html')
console.log(text02) // 输出 index
3. path.extname
path.extname() 获取路径中文件扩展名
格式:
path.extname(path)
path: 文件路径
示例:
// 导入模块
const path = require('path')
const fpath = '/a/b/c/index.html'
const text = path.extname(fpath)
console.log(text) // 输出 .html
http 模块
负责对外提供网络资源的电脑,叫做服务器
http模块,用来创建web服务器的模块
格式:
// 1. 导入 http 模块
const http = require('http')
// 2. 创建 web 服务器实例
const server = http.createServer()
// 3. 为服务器实例绑定 request 事件,监听客户端的请求
server.on('request', function (req, res) {
console.log('Someone visit our web server.')
})
// 4. 启动服务器
server.listen(8080, function () {
console.log('server running at http://127.0.0.1:8080')
})
1. 导入http模块
const http = require('http')
2. 创建web服务器示例
const server = http.createServer()
3. 为服务器示例绑定 request 事件
server.on('reqest',(req,res)=>{
// req 是请求对象
// req.url 是客户端请求的 URL 地址
// req.method 是客户端的 method 请求类型
const str=`Your request url is ${req.url},and method is ${req.method}`
// 防止中文乱码,设置响应头
res.setHeader('Content-Type','text/html;charset=utf-8')
// res.end() 向客户端发送指定内容,并结束处理
res.end(str)
})
4. 绑定监听事件
server.listen(80,()=>{
console.log('http server running at http://127.0.0.1:82')
})
自定义模块
由用户创建的js文件
在自定义模块中定义变量、方法等,只能在当前模块内被访问,
在自定义模块中,可以将变量、方法挂载到 module.exports 对象上,将module.exports 对象暴露出去,外界可以通过 require() 方法导入自定义模块,就可以使用自定义模块的 方法 和 变量
test01.js
#1
module.exports.username = 'zs'
module.exports.sayHello = function() {
console.log('Hello!')
}
#2
module.exports = {
nickname: '小黑',
sayHi() {
console.log('Hi!')
}
}
test02.js
// 导入一个自定义模块的时候
// m 就是那个模块中,通过 module.exports 指向的那个对象
const m = require(__dirname+'./test01.js')
console.log(m)
初始化包
1.以英文名作为包的名字
2.快速创建package.json npm init -y
3.文件夹下有 package.json(管理配置文件) 、index.js(包的入口文件) 、README(包的说明文档)
npm 包
1)nrm:切换镜像
#全局安装nrm
npm i nrm -g
#查看所有可用镜像源
nrm ls
#将镜像源切换为 taobao 镜像
nrm use taobao
#查看当前镜像
npm config get registry
npm config set registry=https://registry.npm.taobao.org/
2) i5ting_toc: md文档转html
#全局安装i5ting_toc
npm i i5ting_toc -g
#md文档转html
i5ting_toc -f md文件路径 -o
3) nodemon: 运行node项目并自动监听
#全局安装
npm install -g nodemon
#运行文件
nodemon 文件名
第三方模块
第三方模块是非官方提供,由第三方模块开发,使用前需要下载
Express
初识 Express
Express 是基于 Node.js 平台的 web 开发框架,通常用来创建Web服务器
安装:
npm i express@4.17.1
示例:
#导入
const express = require('express')
#创建web服务器
const app=express()
...
app.listen(80,()=>{
console.log('express server running at http://127.0.0.1')
})
Express 路由
格式:
app.get('/',(req,res)=>{
req.query为发送到服务器的对象,默认为空
})
app.post('/',(req,res)=>{
req.body为发送到服务器的对象,默认为空
})
app.post('/:id',(req,res)=>{
req.params为通过 :动态匹配的参数
})
托管静态资源:
可以将文件目录下的资源对外开放,域名加路径直接访问
app.use(express.static('public'))
// http://localhost:80/image.jpg
app.use('/text', express.static('public'))
// 挂载前缀,http://localhost:80/public/image.jpg
Express 中间件
中间件特指业务流程的中间处理环节
中间件本质上就是一个function处理函数
注意:
1)要在路由之前注册中间件,错误中间件要在路由之后注册
2)不要忘记调用next()函数,在next()函数后不要写代码
3)连续调用多个中间件时,多个中间件之间,共享 req 和 res 对象
1. 全局中间件
app.use(function(req,res,next){
next()
})
2. 局部中间件
app.get('/',[nw1,nw2,...],(req.res) => { res.send('Home page.')})
3. 错误中间件
错误中间件要在路由之后注册
app.use(function(err,req,res,next){
res.send('Error'+ err.message)
next()
})
4. 内置中间件
① express.static 快速托管静态资源的内置中间件,例如: HTML 文件、图片、CSS 样式等(无兼容性)
② express.json 解析 JSON 格式的请求体数据(有兼容性,仅在 4.16.0+ 版本中可用)
③ express.urlencoded 解析 URL-encoded 格式的请求体数据(有兼容性,仅在 4.16.0+ 版本中可用)
# 配置解析 application/json 格式数据中间件
app.use(express.json())
# 配置解析 application/x-www-form-urlencoded 格式数据的内置中间件
app.use(express.urlencoded({ extended: false }))
路由模块化
为了对路由进行模块化管理,Express不建议将路由挂载到app上,推荐将路由模块抽离为单独的模块
- 调用express.Router() 函数创建路由对象
- 在路由对象上挂载路由
- 使用 module.exports 向外共享路由对象
- 使用app.use()函数注册路由模块
示例:
apiRouter.js
// 1. 导入 express
const express = require('express')
// 2. 创建路由对象
const router = express.Router()
// 3. 挂载具体的路由
router.get('/user/list', (req, res) => {
const query = req.query
res.send({
status:0,
msg:'sucess',
data: query
})
})
// 4. 向外导出路由对象
module.exports = router
index.js
const express = require('express')
const app = express()
// 注意: app.use() 函数的作用,就是来注册全局中间件
app.use('/files', express.static('./files'))
// 1. 导入路由模块
const router = require('./03.router')
// 2. 注册路由模块
app.use('/api', router)
app.listen(80, () => {
console.log('http://127.0.0.1')
})
cors
cors 是 Express 的一个第三方中间件,通过安装配置,可以解决跨域问题
1.安装
npm install cors
2.导入
const cors = require('cors')
3.配置中间件(在路由之前)
app.use(cors())
可以指定 cors 响应头部,指定为 * 表示接受任何域的请求,默认只接受九个固定请求头
res.setHeader('Access-Control-Allow-Origin','*')
还可以指定 cors 支持客户端发起的请求,默认支持GET、POST、HEAD请求
res.setHeader('Access-Control-Allow-Methods','*')
res.setHeader('Access-Control-Allow-Methods','POST,DELETE')
mysql
mysql 基础使用
- 安装第三方模块mysql
npm install mysql
- 通过 mysql 模块连接到 mysql数据库
# 导入
const mysql = require('mysql')
# 建立与 MYSQL 的连接
const db = mysql.createPool({
host:'127.0.0.1', // 数据库的 IP 地址
user:'root', // 登录数据库的账号
password:'admin123', // 登录数据库的密码
database:'my_db_01' // 指定要操作的数据库
})
-
通过 mysql 模块执行 sql 语句
- 增
# 一 const user={ username:'bulen',password:'123456' } cosnt sqlStr=`INSERT INTO users (username,password) VALUES (?,?) db.query(sqlStr,[user.username,user.password],(err,resules)=>{ if(err) return console.log(err.message) if(results.affectedRows===1){ console.log('插入数据成功!')} }) # 二 const user={ username:'bulen',password:'123456' } cosnt sqlStr=`INSERT INTO users SET ?` db.query(sqlStr,user,(err,resules)=>{ if(err) return console.log(err.message) if(results.affectedRows===1){ console.log('插入数据成功!')} })
- 删
const sqlStr=`DELETE FORM users WHERE id=?` # 如果有多个?占位符,则需要用数据包裹起来,例如:[7,6] db.query(sqlStr,7,(err,results)=>{ if(err) return console.log(err.message) if(results.affectedRows===1){ console.log("删除数据成功!")} })
- 改
# 一 const user={ username:'bulen',password:'123456',id:7 } cosnt sqlStr=`UPDATE users SET username=?,password=? WHERE id=?` db.query(sqlStr,[user.username,user.password,user.id],(err,resules)=>{ if(err) return console.log(err.message) if(results.affectedRows===1){ console.log('更新数据成功!')} }) # 二 const user={ username:'bulen',password:'123456' } cosnt sqlStr=`UPDATE users SET ? WHERE id=?` db.query(sqlStr,[user,user.id],(err,resules)=>{ if(err) return console.log(err.message) if(results.affectedRows===1){ console.log('更新数据成功!')} })
- 查
const sqlStr = 'SELECT * FORM users WHERE id=?' db.query(sqlStr,6,(err,result)=>{ if(err) return console.log(err.message) console.log(result) })
接口编写
-
npm init -y
-
npm i express
-
npm i cors
-
npm i mysql
5)编写文件
dbMysql.js
const mysql=require('mysql')
const db=mysql.createPool({
host:'127.0.0.1',
user:'root',
password:'123123',
database:'result'
})
module.exports=db
apiRouter.js
const express=require('express')
const router=express.Router()
const path=require('path')
const db=require(path.join(__dirname,'./dbMysql'))
const sqlStr01=`select * from task01`
router.get('/task1',function(req,res){
db.query(sqlStr01,function(err,results){
if(err) return console.log(err.message);
res.send({
code:200,
msg: '数据获取成功',
data:results
})
})
})
router.post('/task1',function(req,res){
db.query(sqlStr01,function(err,results){
if(err) return console.log(err.message);
res.send({
code:200,
msg: '数据获取成功',
data:results
})
})
})
module.exports=router
index.js
const express=require('express')
const app=express()
const cors=require('cors')
app.use(cors())
const path=require('path')
const apiRouter=require(path.join(__dirname,'./apiRouter'))
app.use('/api',apiRouter)
app.listen(9999,()=>{
console.log('server running at http://127.0.0.1');
})
express-session
session认证机制 用于服务端渲染身份认证
用户登录成功后,服务器将生成对应的 Cookie 字符串发送给浏览器,浏览器自动把 Cookie 字符串存储在当前域名下,用来对用户身份认证。请求头携带 Cookie 查询用户信息,用户认证成功后,对用户生成特定响应内容
- 安装
npm install express-session
- 配置 express-session 中间件
#导入 session 中间件
var session = require('express-session')
#配置
app.use(session({
secret: 'key123', // secret 属性值可以为任意字符串
resave: false,
saveUninitialized:true
}))
-
对session进行操作
1) 从 session 中存数据
2) 从 session 中取数据
3) 清空 session
示例:// 导入 express 模块 const express = require('express') // 创建 express 的服务器实例 const app = express() // TODO_01:请配置 Session 中间件 const session = require('express-session') app.use( session({ secret: 'itheima', resave: false, saveUninitialized: true, }) ) // 托管静态页面 app.use(express.static('./pages')) // 解析 POST 提交过来的表单数据 app.use(express.urlencoded({ extended: false })) // 登录的 API 接口 app.post('/api/login', (req, res) => { // 判断用户提交的登录信息是否正确 if (req.body.username !== 'admin' || req.body.password !== '000000') { return res.send({ status: 1, msg: '登录失败' }) } // TODO_02:请将登录成功后的用户信息,保存到 Session 中 // 注意:只有成功配置了 express-session 这个中间件之后,才能够通过 req 点出来 session 这个属性 req.session.user = req.body // 用户的信息 req.session.islogin = true // 用户的登录状态 res.send({ status: 0, msg: '登录成功' }) }) // 获取用户姓名的接口 app.get('/api/username', (req, res) => { // TODO_03:请从 Session 中获取用户的名称,响应给客户端 if (!req.session.islogin) { return res.send({ status: 1, msg: 'fail' }) } res.send({ status: 0, msg: 'success', username: req.session.user.username, }) }) // 退出登录的接口 app.post('/api/logout', (req, res) => { // TODO_04:清空 Session 信息 req.session.destroy() res.send({ status: 0, msg: '退出登录成功', }) }) // 调用 app.listen 方法,指定端口号并启动web服务器 app.listen(80, function () { console.log('Express server running at http://127.0.0.1:80') })
JWT ( jsonwebtoken,express-jwt)
JWT认证机制 用于前后端分离,session不能接受前端跨域访问
用户登录成功后,服务器将生成对应的 ToKen 字符串发送给浏览器,浏览器自动把 ToKen 存储在本地存储(LocalStorage)或会话存储(SessionStorage)下,用来对用户身份认证。请求头携带 ToKen 查询用户信息,用户认证成功后,对用户生成特定响应内容
JWT 通常由三部分组成,分别是 Header(头部)、Payload(有效荷载)、Signature(签名)。
其中:
⚫ Payload 部分才是真正的用户信息,它是用户信息经过加密之后生成的字符串。
⚫ Header 和 Signature 是安全性相关的部分,只是为了保证 Token 的安全性
三者之间使用英文的“.”分隔,格式如下:
Header.Payload.Signature
客户端收到服务器返回的 JWT 之后,通常会将它储存在 localStorage 或 sessionStorage 中。
此后,客户端每次与服务器通信,都要带上这个 JWT 的字符串,从而进行身份认证。推荐的做法是把 JWT 放在 HTTP
请求头的 Authorization 字段中,格式如下:
Authorization : Bearer <token>
1.安装
# jsonwebtoken 用于生成 JWT 字符串
#express-jwt 用于将 JWT 字符串解析还原成 JSON 对象
npm install jsonwebtoken express-jwt
2.使用
jsonwebtoken : 导入=》设置密钥 =》加密为 ToKen =》发送给客户端
express-jwt :导入 =》设置为全局中间件,设置不需要身份认证的接口 =》错误中间件
const express = require('express')
const app = express()
// TODO_01:安装并导入 JWT 相关的两个包,分别是 jsonwebtoken 和 express-jwt
const jwt = require('jsonwebtoken')
const expressJWT = require('express-jwt')
const cors = require('cors')
app.use(cors())
app.use(bodyParser.urlencoded({ extended: false }))
// TODO_02:定义 secret 密钥,建议将密钥命名为 secretKey
const secretKey = 'key12313'
// TODO_04:注册将 JWT 字符串解析还原成 JSON 对象的中间件
// expressJWT({ secret: secretKey }) 用来解析 ToKen 中间件
// unless({ path: [/^\/api\//] })) 用来指定哪些接口不需要访问权限
app.use(expressJWT({ secret: secretKey }).unless({ path: [/^\/api\//] }))
// 登录接口
app.post('/api/login', function (req, res) {
const userinfo = req.body
if (userinfo.username !== 'admin' || userinfo.password !== '000000') {
return res.send({
status: 400,
message: '登录失败!',
})
}
// 登录成功
// TODO_03:在登录成功之后,调用 jwt.sign() 方法生成 ToKen 字符串。并通过 token 属性发送给客户端
// 参数1:用户的信息对象
// 参数2:加密的秘钥
// 参数3:配置对象,可以配置当前 token 的有效期
// 记住:千万不要把密码加密到 token 字符中
const tokenStr = jwt.sign({ username: userinfo.username }, secretKey, { expiresIn: '10h' })
res.send({
status: 200,
message: '登录成功!',
// 要发送给客户端的 token 字符串,为了方便客户端使用,在这里直接拼接上 Bearer 的前缀
token: 'Bearer'+tokenStr,
})
})
// 这是一个有权限的 API 接口
app.get('/admin/getinfo', function (req, res) {
// TODO_05:使用 req.user 获取用户信息,并使用 data 属性将用户信息发送给客户端
console.log(req.user)
res.send({
status: 200,
message: '获取用户信息成功!',
data: req.user, // 要发送给客户端的用户信息
})
})
// TODO_06:使用全局错误处理中间件,捕获解析 JWT 失败后产生的错误
app.use((err, req, res, next) => {
// 这次错误是由 token 解析失败导致的
if (err.name === 'UnauthorizedError') {
return res.send({
status: 401,
message: '身份认证失败!',
})
}
})
app.listen(8888, function () {
console.log('Express server running at http://127.0.0.1:8888')
})
bcryptjs
bcryptjs对密码进行加密,优点是 1. 无法逆向破解,2. 同意密码多次加密,得到的结果不同
1.安装
2.
npm i bcryptjs@2.4.3
2.导入
const bcrypt = require('bcryptjs')
3.使用
- 加密: 在注册用户的处理函数中,确认用户名可用之后,调用 bcrypt.hashSync(明文密码, 随机盐的
长度) 方法,对用户的密码进行加密处理:
// 对用户的密码,进行 bcrype 加密,返回值是加密之后的密码字符串
userinfo.password = bcrypt.hashSync(userinfo.password, 10)
2)对比密码:调用 bcrypt.compareSync(用户提交的密码, 数据库中的密码) 方法比较密码是
否一致,返回值是布尔值(true 一致、false 不一致)
// 拿着用户输入的密码,和数据库中存储的密码进行对比
const compareResult = bcrypt.compareSync(userinfo.password, results[0].password)
joi and express-joi
joi and express-joi 用来对接受到的数据进行数据验证
npm 包搜索里面有使用文档 : https://www.npmjs.com/package/joi
1.安装
定义验证规则
npm i joi
验证功能
npm i express-joi
2.使用
schema.js
const joi = require('joi')
/**
* string() 值必须是字符串
* alphanum() 值只能是包含 a-zA-Z0-9 的字符串
* min(length) 最小长度
* max(length) 最大长度
* required() 值是必填项,不能为 undefined
* pattern(正则表达式) 值必须符合正则表达式的规则
*/
// 用户名的验证规则
const username = joi.string().alphanum().min(1).max(10).required()
// 密码的验证规则
const password = joi
.string()
.pattern(/^[\S]{6,12}$/)
.required()
// 注册和登录表单的验证规则对象
exports.reg_login_schema = {
// 表示需要对 req.body 中的数据进行验证
body: {
username,
password,
oldPwd: password,
// 解读:
// 1. joi.ref('oldPwd') 表示 newPwd 的值必须和 oldPwd 的值保持一致
// 2. joi.not(joi.ref('oldPwd')) 表示 newPwd 的值不能等于 oldPwd 的值
// 3. .concat() 用于合并 joi.not(joi.ref('oldPwd')) 和 password 这两条验证规则
newPwd: joi.not(joi.ref('oldPwd')).concat(password),
},
}
router.js
const express = require('express')
const router = express.Router()
const userHandler = require('../router_handler/user')
// 1. 导入验证表单数据的中间件
const expressJoi = require('@escook/express-joi')
// 2. 导入需要的验证规则对象
const { reg_login_schema } = require('./schema')
// 注册新用户
// 3. 在注册新用户的路由中,声明局部中间件,对当前请求中携带的数据进行验证
// 3.1 数据验证通过后,会把这次请求流转给后面的路由处理函数
// 3.2 数据验证失败后,终止后续代码的执行,并抛出一个全局的 Error 错误,进入全局错误级别中间件
中进行处理
router.post('/reguser', expressJoi(reg_login_schema), userHandler.regUser)
module.exports = router
app.js
const joi = require('@hapi/joi')
// 错误中间件
app.use(function (err, req, res, next) {
// 数据验证失败
if (err instanceof joi.ValidationError) return res.cc(err)
// 未知错误
res.cc(err)
})