express开发框架
1. 简介
基于 Node.js 平台,快速、开放、极简的 Web 开发框架 Express官网网站
简单讲,Express 的作用和 Node.js 内置的 http 模块类似,是专门用来创建 Web 服务器的,Express 是基于内置的 http 模块进一步封装出来的,能够极大的提高开发效率
Express 的本质:就是一个 npm 上的第三方包,提供了快速创建 Web 服务器的便捷方法
1.1 作用
对于前端来说,最常见的两种服务器,分别是Web网站服务器和API接口服务器
1、 Web 网站服务器:专门对外提供 Web 网页资源的服务器
2、 API 接口服务器:专门对外提供 API 接口的服务器
使用 Express,可以方便、快速的创建 Web 网站的服务器或 API 接口的服务器
2. 项目创建和安装依赖
# 1. 初始化项目
npm init -y
# 2. 安装 Express 并将其保存到依赖列表中
npm install express --save
# 3. 直接使用
参考案例:我的第一个hello world
3. 案例解析
// 1. 引入express
var express = require('express')
// 2. 创建服务器应用程序,也就是原来的 http.createServer
var app = express()
// 3. 请求和响应
// 当服务器收到 get 请求 / 的时候,执行回调处理函数
app.get('/', function(req, res) {
// 在 Express 中可以直接 req.query 来获取查询字符串参数
console.log(req.query)
// 通过 res.send() 方法,可以把处理好的内容,发送给客户端
res.send('Hello World!')
})
// 登陆页面
app.get('/login', function(req, res) {
res.send('Login page')
})
// 4. 统一处理网站静态资源,你就可以直接通过 /public/xx 的方式访问 public 目录中的所有资源了
// 当以 /public/ 开头的时候,去 ./public/ 目录中找找对应的资源
app.use('/public/', express.static('./public/')) // 推荐使用这种方式
// 当省略第一个参数的时候,则可以直接访问./public里面的资源, 省略 /public 的来访问
// 比如之前访问 locallhost:/public/login.html ,现在就可以这样访问:locallhost:/login.html
// 这种方式的好处就是可以省略 /public/
app.use(express.static('./public/'))
// 5. 监听并设置端口号
app.listen(3000, function() {
console.log(`Example app listening at http://localhost:3000`)
})
注意:Express 对于没有设定的请求路径,默认会返回 Cat not get xxx,如果你想要定制自己的404页面,只需要在自己的路由之后增加如下设置即可
app.use(function (req, res) {
// 所有未处理的请求路径都会跑到这里
// 404 页面
})
3.1 路由
路由其实就是映射关系,在 Express 中,路由指的是客户端的请求与服务器处理函数之间的映射关系
Express 中的路由分 3 部分组成,分别是请求的类型、请求的 URL 地址、处理函数,格式如下:
app.Method(path,handler)
get请求
// 当以get方法请求 / 的时候,执行对应的处理函数
app.get('/',function(req,res){
res.send('hello world');
})
post请求
// 当以post方法请求 / 的时候,执行对应的处理函数
app.post('/',function(req,res){
res.send('hello world');
})
3.1.1 路由的匹配过程
每当一个请求到达服务器之后,需要先经过路由的匹配,只有匹配成功之后,才会调用对应的处理函数。
在匹配时,会按照路由的顺序进行匹配,如果请求类型和请求的 URL 同时匹配成功,则 Express 会将这次请求,转 交给对应的 function 函数进行处理
3.1.2 模块化路由处理 express.Router()
为了方便对路由进行模块化的管理,Express 不建议将路由直接挂载到 app 上,而是推荐将路由抽离为单独的模块。
将路由抽离为单独模块的步骤如下:
① 创建路由模块对应的 .js 文件
② 调用 express.Router() 函数创建路由对象
③ 向路由对象上挂载具体的路由
④ 使用 module.exports 向外共享路由对象
⑤ 使用 app.use() 函数注册路由模块
创建一个路由模块 router.js
var express = require('express')
// 1. 创建一个路由容器对象,Express 提供的,专门用来包装路由的
var router = express.Router()
// 2. 把路由都挂载到 router 路由容器中
router.get('/', function (req, res, next) {
res.send('加载成功')
})
// 3. 导出路由
module.exports = router
注册路由
var express = require('express')
// 引入路由模块
var router = require('./routers')
// 0. 创建web服务器
var app = express()
// 将路由挂载到app中
app.use(router)
app.listen(3000, function () {
console.log('Server is runing at http://localhost:3000/')
})
注册一个二级路由
为路由模块添加前缀
// 设置二级路由--用户个人信息配置模块 里面的页面访问路径是 /user/XXX
var profile = require('./profile');
// 注册路由模块,并添加访问理由前缀
router.use('/user', profile)
3.2 统一处理静态资源
app.use 不仅仅是用来处理静态资源的,还可以做很多工作(body-parser的配置)
访问 目录 public下面的index.html 资源
// 方式一: http://localhost:3000/public/index.html
app.use('/public',express.static('public'));
// 推荐使用
app.use('/public',express.static(path.join(__dirname+'public')));
// 方式二: http://localhost:3000/index.html 可以不写 public
app.use(express.static('public'));
// 方式三: http://localhost:3000/static/index.html
app.use('/static',express.static('public'));
3.3 express结合 express-art-template案例
var path = require('path')
var express = require('express')
// 1. 创建web服务器
var app = express()
// 2. 指定.html使用的解析引擎(官方给出的是art)
app.engine('html', require('express-art-template'))
// 3. express-art-template 默认的渲染的目录是 views 下面的,如果需要修,则设置如下:
app.set('views', path.join(__dirname, 'www')); // www 目录是放置模板html的位置
// 请求与响应
app.get('/', function (req, res) {
// 使用模板传值
res.render('index.html', {
name: '李思雨',
age: 18,
province: '北京市',
hobbies: [
'写代码',
'唱歌',
'打游戏'
],
title: '个人信息'
});
});
app.listen(3000, function () {
console.log('server is running ......')
})
修好默认的模板路径 views
// 3. express-art-template 默认的渲染的目录是 views 下面的,如果需要修,则设置如下:
app.set('views', path.join(__dirname, 'www')); // www 目录是放置模板html的位置
3.4 获取 url
中携带的参数
3.4.1 获取 get 请求传递的参数
获取 URL 中携带的查询参数
通过 req.query 对象,可以访问到客户端通过查询字符串的形式,发送到服务器的参数
客户端使用 ?name=zs&age=19
这种查询字符串的形式
app.get('/user', (req, res) => {
// 返回: { name: 'zs', age: '19' }
console.log(req.query);
res.send('获取 http://localhost:3000/user?name=zs&age=19 请求的参数')
})
获取 URL 中的动态参数
通过 req.params
对象,可以访问到 URL 中,通过 :
匹配到的动态参数
app.get('/user/:ids/:name', (req, res) => {
// 返回: { ids: '90', name: 'Tom' }
console.log(req.params);
res.send('获取 http://localhost:3000/user/90/Tom 请求的参数')
})
3.4.2 获取 post 请求传递的参数
使用 body-parser
中间件,req.body
方式获取
// 0. 引入 body-parser
const bodyParser = require('body-parser')
// 1. 创建web服务器
var app = express()
// 2. 配置模板引擎和 body-parser 一定要在 app.use(router) 挂载路由之前
app.use(bodyParser.urlencoded({
extended: false
}))
app.use(bodyParser.json())
4. Express之中间件
4.1 概述
中间件的本质就是一个请求处理方法,我们把用户从请求到响应的整个过程分发到多个中间件去处理,这样做的目的就是提高代码的灵活性,动态可扩展
当一个请求到达 Express 的服务器之后,可以连续调用多个中间件,从而对这次请求进行预处理
中间件请求处理顺序:
- 当请求进来,会从第一个中间件开始进行匹配
- 如果匹配,则进来
- 如果请求进入中间件之后,没有调用 next 则代码会停在当前中间件
- 如果调用了 next 则继续向后找到第一个匹配的中间件
- 如果不匹配,则继续判断匹配下一个中间件
4.1.1 next 方法
中间件的主要功能就是用来处理请求的,其本质还是函数,而且必须包含 next 方法
next方法:当一个请求进入一个中间件之后,如果不调用 next 则会停留在当前中间件,所以 next 是一个方法,用来调用下一个中间件的
next 函数是实现多个中间件连续调用的关键,它表示把流转关系转交给下一个中间件或路由
// 可以使用 app.use() 连续定义多个全局中间件。
// 客户端请求到达服务器之后,会按照中间件定义的先后顺序依次进行调用
var express = require('express')
var app = express()
app.use(function(req, res, next) {
console.log('1')
next() // 如果此处没有next(),则不会继续往下执行,会继续停留在当前中间件
})
app.use(function(req, res, next) {
console.log('2')
next()
})
app.listen(3000, function() {
console.log('app is running at port 3000.')
})
4.1.2 作用
多个中间件之间,共享同一份 req 和 res。基于这样的特性,我们可以在上游的中间件中,统一为 req 或 res 对象添 加自定义的属性或方法,供下游的中间件或路由进行使用
4.1.3 注意事项
1、 一定要在路由之前注册中间件
2、 客户端发送过来的请求,可以连续调用多个中间件进行处理
3、 执行完中间件的业务代码之后,不要忘记调用 next() 函数
4、 为了防止代码逻辑混乱,调用 next() 函数后不要再写额外的代码
5、 连续调用多个中间件时,多个中间件之间,共享 req 和 res 对象
4.2 中间件的分类
4.2.1 应用级别中间件
通过 app.use() 或 app.get() 或 app.post() ,绑定到 app 实例上的中间件,叫做应用级别的中间件
// 全局中间件
app.use(function(req, res, next) {
console.log('a')
next()
})
// 局部中间件
const mw1 = (req, res, next) => {
console.log('调用了局部生效的中间件')
next()
}
app.get('/', mw1, (req, res) => {
res.send('Home page.')
})
4.2.2 路由级别中间件
绑定到 express.Router() 实例上的中间件,叫做路由级别的中间件
它的用法和应用级别中间件没有任何区别。只不 过,应用级别中间件是绑定到 app 实例上,路由级别中间件绑定到 router 实例上
// 1. 导入 express 模块
const express = require('express')
// 2. 创建 路由实例对象
const router = express.Router();
// 3. 创建路由
router.get('/', (req, res) => {
res.send('Home page GET request')
})
router.post('/', (req, res) => {
res.send('Home page POST request')
})
module.exports = router
4.2.3 错误级别中间件
错误级别中间件的作用:专门用来捕获整个项目中发生的异常错误,从而防止项目异常崩溃的问题。
格式:错误级别中间件的 function 处理函数中,必须有 4 个形参,形参顺序从前到后,分别是 (err, req, res, next)
app.get('/a', function(req, res, next) {
fs.readFile('.a/bc', funtion() {
if (err) {
// 当调用next()传参后,如果传递了参数,则直接往后知道带有4个参数的的 处理错误的中间件
// 当发生全局错误的时候,我们可以调用next传递错误对象
// 然后被全局错误处理中间件匹配到并进行处理
return next(err);
}
})
});
// 全局错误处理中间件:注意:参数一定是4个
app.use(function(err,req,res,next){
res.status(500).json({
err_code:500,
message:err.message
});
});
错误级别的中间件, 必须注册在所有路由之后
4.2.4 express内置中间件
自 Express 4.16.0 版本开始,Express 内置了 3 个常用的中间件,极大的提高了 Express 项目的开发效率和体验:
① express.static 快速托管静态资源的内置中间件,例如: HTML 文件、图片、CSS 样式等(无兼容性)
var express = require('express')
// 0. 创建web服务器
var app = express()
// 1. 开放网站统一静态资源:使用 express.static 内置的中间件
app.use('/public/', express.static(path.join(__dirname, './public')))
app.listen(3000, function () {
console.log('Server is runing at http://localhost:3000/')
})
② express.json 解析 JSON 格式的请求体数据(有兼容性,仅在 4.16.0+ 版本中可用) app.use(express.json())
// 导入 express 模块
const express = require('express')
// 创建 express 的服务器实例
const app = express()
// 注意:除了错误级别的中间件,其他的中间件,必须在路由之前进行配置
// 通过 express.json() 这个中间件,解析表单中的 JSON 格式的数据
app.use(express.json())
app.post('/user', (req, res) => {
// 在服务器,可以使用 req.body 这个属性,来接收客户端发送过来的请求体数据
// 默认情况下,如果不配置解析表单数据的中间件,则 req.body 默认等于 undefined
console.log(req.body)
res.send('ok')
})
// 调用 app.listen 方法,指定端口号并启动web服务器
app.listen(3000, function () {
console.log('Server is runing at http://localhost:3000/')
})
③ express.urlencoded 解析 URL-encoded 格式的请求体数据(有兼容性,仅在 4.16.0+ 版本中可用)
app.use(express.urlencoded({ extended: false }))
// 导入 express 模块
const express = require('express')
// 创建 express 的服务器实例
const app = express()
// 通过 express.urlencoded() 这个中间件,来解析 表单中的 url-encoded 格式的数据
app.use(express.urlencoded({ extended: false }))
app.post('/book', (req, res) => {
// 在服务器端,可以通过 req,body 来获取 JSON 格式的表单数据和 url-encoded 格式的数据
console.log(req.body)
res.send('ok')
})
// 调用 app.listen 方法,指定端口号并启动web服务器
app.listen(3000, function () {
console.log('Server is runing at http://localhost:3000/')
})
4.2.5 404页面处理中间件
// 404 处理 所要未处理的请求路径都会在这里处理
app.use(function (req, res) {
res.render("404.html")
})
4.2.6 第三方中间件
1 body-parser
解析post请求体参数
在 4.16.0+ 以前的版本中,一把是使用 body-parser
这个第三方的中间来解析处理post请求体中的参数的
处理post请求参数的中间件
var express = require('express')
// 引入第三方中间件,处理 post 请求体中的参数
var bodyParser = require('body-parser')
// 引入路由模块
var router = require('./routers')
// 0. 创建web服务器
var app = express()
// 2. 配置模板引擎和 body-parser
app.use(bodyParser.urlencoded({
extended: false
}))
app.use(bodyParser.json())
app.listen(3000, function () {
console.log('Server is runing at http://localhost:3000/')
})
Express 内置的 express.urlencoded 中间件,就是基于 body-parser 这个第三方中间件进一步封装出来的
2 cors 跨域请求
解决接口跨域问题的方案主要有两种:
CORS(主流的解决方案,推荐使用)
JSONP(有缺陷的解决方案:只支持 GET 请求)
cors 是 Express 的一个第三方中间件。通过安装和配置 cors 中间件,可以很方便地解决跨域问题
下载安装依赖
npm i cors
配置
// 0. 引入
const cors = require('cors')
// 1. 配置:在路由之前调用
app.use(cors())
multer 处理 multipart/form-data
表单数据
使用 multer 来解析 multipart/form-data
格式的表单数据
使用
express.urlencoded()
中间件无法解析multipart/form-data
格式的请求体数据
下载安装依赖
npm i multer
在路由模块中配置
// 导入解析 formdata 格式表单数据的包
const multer = require('multer')
// 导入处理路径的核心模块
const path = require('path')
// 创建 multer 的实例对象,通过 dest 属性指定 上传的文件的存放路径
const upload = multer({ dest: path.join(__dirname, '../uploads') })
// 发布新文章的路由
// 将文件类型的数据,解析并挂载到 req.file 属性中
// 将文本类型的数据,解析并挂载到 req.body 属性中
router.post('/add', upload.single('cover_img'), articleHandler.addArticle)
upload.single() 是一个局部生效的中间件,用来解析 FormData 格式的表单数据
将文件类型的数据,解析并挂载到 req.file 属性中
将文本类型的数据,解析并挂载到 req.body 属性中
5 跨域
5.1 概述
CORS (Cross-Origin Resource Sharing,跨域资源共享)由一系列 HTTP 响应头组成,这些 HTTP 响应头决定 浏览器是否阻止前端 JS 代码跨域获取资源。
浏览器的同源安全策略默认会阻止网页“跨域”获取资源。但如果接口服务器配置了 CORS 相关的 HTTP 响应头, 就可以解除浏览器端的跨域访问限制
CORS 主要在服务器端进行配置。客户端浏览器无须做任何额外的配置,即可请求开启了 CORS 的接口
CORS 在浏览器中有兼容性。只有支持 XMLHttpRequest Level2 的浏览器,才能正常访问开启了 CORS 的服 务端接口(例如:IE10+、Chrome4+、FireFox3.5+)。
5.2 CORS 响应头部
5.2.1 Access-Control-Allow-Origin
origin 参数的值指定了允许访问该资源的外域 URL
// 只允许来自 http://itcast.cn 的请求:
res.setHeader('Access-Control-Allow-Origin', 'http://itcast.cn')
// 表示允许来自任何域的请求
res.setHeader('Access-Control-Allow-Origin', '*')
5.2.2 Access-Control-Allow-Headers
默认情况下,CORS 仅支持客户端向服务器发送如下的 9 个请求头,如果客户端向服务器发送了额外的请求头信息,则需要在服务器端,通过 Access-Control-Allow-Headers 对额外 的请求头进行声明,否则这次请求会失败!
- Accept
- Accept-Language
- Content-Language
- DPR
- Downlink
- Save-Data
- Viewport-Width
- Width
- Content-Type (仅限 text/plain、multipart/form-data、application/x-www-form-urlencoded 三者之一)
// 允许客户端 额外向服务器 发送 Content-type 请求头 和 X-Custom-Header 请求头
res.setHeader('Access-Control-Allow-Headers', 'Content-type,X-Custom-Header')
5.2.3 Access-Control-Allow-Methods
默认情况下,CORS 仅支持客户端发起 GET、POST、HEAD 请求
如果客户端希望通过 PUT、DELETE 等方式请求服务器的资源,则需要在服务器端,通过 Access-Control-Alow-Methods
来指明实际请求所允许使用的 HTTP 方法。 示例代码如下
// 允许所有的 http 请求方法
res.setHeader('Access-Control-Allow-Methods', '*')
// 只允许所有的 GET,POST,DELETE, HEAD 请求方法
res.setHeader('Access-Control-Allow-Methods', 'GET,POST,DELETE, HEAD')
5.3 CORS请求分类
客户端在请求 CORS 接口时,根据请求方式和请求头的不同,可以将 CORS 的请求分为两大类,分别是:简单请求 和 预检请求
5.3.1 简单请求
简单请求: 同时满足以下两大条件的请求,就属于简单请求:
1、 请求方式:GET、POST、HEAD 三者之一
2、 HTTP 头部信息不超过以下几种字段:无自定义头部字段、Accept、Accept-Language、Content-Language、DPR、 Downlink、Save-Data、Viewport-Width、Width 、Content-Type(只有三个值application/x-www-formurlencoded、multipart/form-data、text/plain)
简单请求:客户端与服务器之间只会发生一次请求
5.3.2 预检请求
预检请求:只要符合以下任何一个条件的请求,都需要进行预检请求:
1、 请求方式为 GET、POST、HEAD 之外的请求 Method 类型
2、 请求头中包含自定义头部字段
3、 向服务器发送了 application/json
格式的数据
预检请求的过程:
在浏览器与服务器正式通信之前,浏览器会先发送 OPTION 请求进行预检,以获知服务器是否允许该实际请求,所以这一 次的 OPTION 请求称为“预检请求”。服务器成功响应预检请求后,才会发送真正的请求,并且携带真实数据
预检请求:客户端与服务器之间会发生两次请求,OPTION 预检请求成功之后,才会发起真正的请求
6 数据库 MySQL
6.1 概述
数据库(database)是用来组织、存储和管理数据的仓库。
用户可以对数据库中的数 据进行新增、查询、更新、删除等操作
6.2 常见数据库及其分类
市面上的数据库有很多种,最常见的数据库有如下几个:
- MySQL 数据库(目前使用最广泛、流行度最高的开源免费数据库;Community + Enterprise)
- Oracle 数据库(收费)
- SQL Server 数据库(收费)
- Mongodb 数据库(Community + Enterprise)
其中,MySQL、Oracle、SQL Server 属于传统型数据库(又叫做:关系型数据库 或 SQL 数据库),这三者的 设计理念相同,用法比较类似。
而 Mongodb 属于新型数据库(又叫做:非关系型数据库 或 NoSQL 数据库),它在一定程度上弥补了传统型 数据库的缺陷
6.3 SQL基本操作
SQL(英文全称:Structured Query Language)是结构化查询语言,专门用来访问和处理数据库的编程语言。能够让 我们以编程的形式,操作数据库里面的数据
6.3.1 查询 select
SELECT 语句用于从表中查询数据。执行的结果被存储在一个结果表中(称为结果集)。
-- 通过 * 把 users 表中所有的数据查询出来
select * from users
-- 从 users 表中把 username 和 password 对应的列数据查询出来
select username, password from users
6.3.2 插入 insert into
INSERT INTO 语句用于向数据表中插入新的数据行
INSERT INTO 表名 (列名1,列名2,列名3...) values (值1,值2,值3...)
-- 向 users 表中,插入一条 username 为 admin,password 为 123456 的用户数据
insert into users (username,password) values ('admin','123456')
6.3.3 更新 update
update 语句用于修改表中的数据
UPDATE 表名 set 列名称=新值 where 列名称=某值
-- 把 users 表中 id 为 7 的用户密码,更新为 888888
update users set password='888888' where id=7
-- 把 users 表中 id 为 2 的用户密码和用户状态,分别更新为 admin123 和 1
-- 更改多列数据,使用 , 隔开
update users set password='admin123', status=1 where id=2
6.3.4 删除 delete
DELETE 语句用于删除表中的行
DELETE FROM 表名 WHERE 列名称=值
-- 删除 users 表中, id 为 4 的用户
delete from users where id=4
6.3.5 子句 where
WHERE 子句用于限定选择的标准(条件)。在 SELECT、UPDATE、DELETE 语句中,皆可使用 WHERE 子句来限定选择的标准
select 列名 from 表名 where 列 运算符 值
update 表名 set 列=新值 where 列 运算符 值
delete from 表名 where 列 运算符 值
运算符常用如下:
操作符 | 说明 |
---|---|
= | 等于 |
<> 或者 != | 不等于 |
> | 大于 |
< | 小于 |
>= | 大于等于 |
<= | 小于等于 |
between | 在某个搜索范围内查找 |
like | 搜索某种模式 |
-- 查询 status 为 1 的所有用户
select * from users where status=1
-- 查询 id 大于 2 的所有用户
select * from users where id>=2
-- 查询 username 不等于 ls 的所有用户
select * from users where username<>'ls'
select * from users where username!='ls'
6.3.6 ADN
和 OR
AND 和 OR 可在 WHERE 子语句中把两个或多个条件结合起来
AND 表示必须同时满足多个条件,相当于 JavaScript 中的 && 运算符
OR 表示只要满足任意一个条件即可,相当于 JavaScript 中的 || 运算符
-- 查询 所有状态为0且id小于3的用户
select * from users where status=0 and id<3
-- 查询 所有状态为1 或 username 为 zs 的用户
select * from users where status=1 or username='zs'
6.3.7 order by
排序
ORDER BY 语句用于根据指定的列对结果集进行排序。
ORDER BY 语句默认按照升序(ASC)对记录进行排序
如果您希望按照降序对记录进行排序,可以使用 DESC 关键字
-- desc 表示降序排序 asc 表示升序排序(默认情况下,就是升序排序的)
-- 1. 对users表中的数据,按照 status 字段进行升序排序
select * from users order by status
-- 2. 按照 id 对结果进行降序的排序
select * from users order by id desc
-- 3. 对 users 表中的数据,先按照 status 进行降序排序,再按照 username 字母的顺序,进行升序的排序
select * from users order by status desc, username asc
6.3.8 COUNT(*)
函数
COUNT(*) 函数用于返回查询结果的总数据条数
-- 使用 count(*) 来统计 users 表中,状态为 0 用户的总数量
select count(*) from users where status=0
6.3.9 AS 设置别名
如果希望给查询出来的列名称设置别名,可以使用 AS 关键字
-- 使用 AS 关键字给列起别名
select count(*) as total from users where status=0
select username as uname, password as upwd from users
7 Node操作MySQL数据库
7.1 安装项目依赖
mysql 模块是托管于 npm 上的第三方模块。它提供了在 Node.js 项目中连接和操作 MySQL 数据库的能力。 想要在项目中使用它,需要先运行如下命令,将 mysql 安装为项目的依赖包:
npm i mysql
7.2 配置 mysql 连接
// 0. 引入项目依赖 mysql
var mysql = require('mysql');
// 1. 创建数据库连接
var connection = mysql.createConnection({
host: 'localhost', // localhost==本机
port: '3356', // 端口号
user: 'root', // 用户名
password: 'root', // 密码
database: 'dbname' // 数据库名
});
// 2. 连接数据库
connection.connect();
// 3. sql查询
// 4. 关闭连接
connection.end();
// 或者采用下面的方式 创建连接也可以
// 1. 导入 mysql 模块
const mysql = require('mysql')
// 2. 建立与 MySQL 数据库的连接关系
const db = mysql.createPool({
host: '127.0.0.1', // 数据库的 IP 地址
user: 'root', // 登录数据库的账号
password: 'admin123', // 登录数据库的密码
database: 'my_db_01', // 指定要操作哪个数据库
})
7.3 使用
7.3.1 查询
查询 users 表中所有的数据
const sqlStr = 'select * from users'
db.query(sqlStr, (err, results) => {
// 查询数据失败
if (err) return console.log(err.message)
// 查询数据成功
// 注意:如果执行的是 select 查询语句,则执行的结果是数组
console.log(results)
})
7.3.2 插入/新增
向 users 表中,新增一条数据,其中 username 的值为 Spider-Man,password 的值为 pcc123
// 1. 定义一个待插入的数据对象
const user = { username: 'Spider-Man', password: 'pcc123' }
// 2. 定义待执行的 SQL 语句:? 表示占位符
const sqlStr = 'insert into users (username, password) values (?, ?)'
// 3. 执行 SQL 语句:使用数组的形式,依次为 上面的占位符指定具体的值
db.query(sqlStr, [user.username, user.password], (err, results) => {
// 执行 SQL 语句失败了
if (err) return console.log(err.message)
// 注意:如果执行的是 insert into 插入语句,则 results 是一个对象
// 可以通过 affectedRows 属性,来判断是否插入数据成功
if (results.affectedRows === 1) {
console.log('插入数据成功!')
}
})
向表中新增数据时,如果数据对象的每个属性和数据表的字段一一对应,则可以通过如下方式快速插入数据
// 1. 定义一个待插入的数据对象
const user = { username: 'Spider-Man2', password: 'pcc4321' }
// 2. 定义待执行的 SQL 语句
const sqlStr = 'insert into users set ?'
// 3. 执行 SQL 语句:直接将数据对象作为占位符的值
db.query(sqlStr, user, (err, results) => {
if (err) return console.log(err.message)
if (results.affectedRows === 1) {
console.log('插入数据成功')
}
})
7.3.3 更新
将 id 为6的用户的用户名和密码更新为 aaa 000
// 1. 要更新的对象
const user = { id: 6, username: 'aaa', password: '000' }
// 2. 定义 SQL 语句,设置占位符
const sqlStr = 'update users set username=?, password=? where id=?'
// 3. 执行 SQL 语句:依次为占位符赋值
db.query(sqlStr, [user.username, user.password, user.id], (err, results) => {
if (err) return console.log(err.message)
// 注意:执行了 update 语句之后,执行的结果,也是一个对象,可以通过 affectedRows 判断是否更新成功
if (results.affectedRows === 1) {
console.log('更新成功')
}
})
更新表数据时,如果数据对象的每个属性和数据表的字段一一对应,则可以通过如下方式快速更新表数据:
// 1. 要更新的对象
const user = { id: 6, username: 'aaa', password: '000' }
// 2. 定义 SQL 语句,设置占位符
const sqlStr = 'update users set ? where id=?'
// 3. 执行 SQL 语句:依次为占位符赋值
db.query(sqlStr, [user, user.id], (err, results) => {
if (err) return console.log(err.message)
// 注意:执行了 update 语句之后,执行的结果,也是一个对象,可以通过 affectedRows 判断是否更新成功
if (results.affectedRows === 1) {
console.log('更新成功')
}
})
7.3.4 删除
在删除数据时,推荐根据 id 这样的唯一标识,来删除对应的数据
删除 id 为 5 的用户
// 1. 要执行的sql语句
const sqlStr = 'delete from users where id=?'
// 2. 执行 SQL 语句:依次为占位符赋值
db.query(sqlStr, 5, (err, results) => {
if (err) return console.log(err.message)
// 注意:执行 delete 语句之后,结果也是一个对象,也会包含 affectedRows 属性
if (results.affectedRows === 1) {
console.log('删除数据成功')
}
})
如果sql语句中有多个占位符,必须使用数组为每个占位符指定特定的值
如果sql语句中有1个占位符,则可以省略数组