Node.js概述

基于JS，运行在服务器端的JS解释器。
(1)对比JS和Node.js
JS运行在客户端浏览器，存在多款浏览器，存在代码兼容性问题；Node.js运行在服务器端，只有一种环境，不存在兼容性问题。
两者都有内置对象、自定义对象，不同的宿主对象
JS用于开发浏览器端的交互效果，Node.js用于服务器端的开发，数据库的操作、其它服务器的访问…
(2)执行方式

脚本模式	node 拖拽文件 回车
交互模式	node 回车 进入交互模式, 两次ctrl+c 退出交互模式

(3)特点及应用场景
单线程运行逻辑，适合做基于社交网络的大规模的web应用，例如微博、抖音…
2.全局对象
(1)global
检测一个变量或者函数是不是全局下的，如果是可以通过global来访问

Node.js下每一个文件都是在一个模块作用域下，变量和函数都是局部的，有效的防止污染全局。

(2)console ---- 控制台对象
console.log(1);//日志
console.info(2);//消息
console.warn(3);//警告
console.error(4);//错误
console.time() //开始计时
console.timeEnd() //结束计时

//开始计时
console.time('ran');
for(var i=1;i<=100000;i++){
}
//结束计时
console.timeEnd('ran');

开始计时和结束计时两者的参数要保持一致。

(3)process对象
进程
arch 查看CPU的架构
platform 查看当前的操作系统版本
version 查看当前Node.js的版本
pid 查看当前进程的编号
kill() 结束指定编号的进程

(4)Buffer对象
缓冲区、缓冲器，位于内存中，临时存储数据的区域，常用于保存网络传输的资源，例如在线视频…
Buffer.alloc(5, ‘abcde’) 创建buffer为5个字节，并存储数据，1个汉字占3个字节。
String() / toString() 将buffer转为字符串

//创建buffer
var buf=Buffer.alloc(5, 'abcde');
console.log(buf);
//转字符串
console.log( String(buf), buf.toString() );

3.模块
模块是一个独立的功能体，每一个文件都是模块
模块之间是引入和被引入的关系
模块分为自定义模块、核心模块、第三方模块
require: 是一个函数，用于引入其它的模块
module.exports: 当前模块导出的内容，默认是一个空对象，如果要导出哪些内容，只需要放入到对象中。

//在模块作用域下
var a=1;
function fn(){
  return 2;
}
//导出的对象，包含了外部可以使用的内容
//导出fn
module.exports={
  name:'然哥',
  a1:a,
  fn1: fn
}

//把引入成功的模块赋给变量，得到的是该模块导出的内容
var obj=require('./07_yan.js');
console.log(obj);
console.log(obj.a1);
//调用fn
console.log( obj.fn1() );

--------模块下的两个局部变量
__dirname: 当前模块的绝对目录
__filename: 当前模块的绝对目录和模块名称

---------模块分类

---------包和npm
包（package）：就是第三方的模块，是目录形式的模块
网址： www.npmjs.com
npm：管理包的工具，包括下载安装、上传、卸载、升级… nodejs安装的时候自动附带安装
npm -v 查看npm的版本号
(1)切换命令行路径
方法1
cd 路径 回车
如果有盘符的变化，需要添加一步
盘符名称: 回车
方法2
在指定目录的空白区域，按住shift，单击鼠标右键，选择’在此处打开powershell窗口’
(2)常用的npm命令
npm init -y 初始化项目说明文件package.json
npm config get registry 获取当前下载仓库的地址
npm config set registry https://registry.npm.taobao.org 设置下载仓库地址为淘宝镜像(改为国内下载)
npm install 包的名称 下载安装指定的包，会自动将包放入node_modules目录中，如果node_modules目录不存在会自动创建；会在package.json中记录下载安装的包名称和版本号；会生成文件package-lock.json，用于记录依赖的包的版本号。
npm install 自动安装package.json和package-lock.json中记录的已经安装的包的名称和版本号。
npm run 快捷名称 自动到package.json中，scripts下对应的名称并运行

npx 在npm5.2以后自动安装的工具
npx -p node@8 node 文件名称
在使用nodejs运行文件之前，先去下载指定的nodejs版本，然后再运行文件；运行完以后再把下载的nodejs删除。

4.查询字符串模块(querystring)
查询字符串是浏览器端向web服务器传递数据的一种方式，位于URL中
https://search.jd.com/Search?keyword=汽车&enc=utf-8
(问号后面内容)

查询字符串模块用于操作查询字符串的工具
parse() 将查询字符串解析为对象，可以得到传递的数据

5.URL模块
URL: 统一资源定位，互联网上任何资源都有对应的URL，通过这个URL可以找到该资源。
http://www.codeboy.com:9999/product_details.html?lid=5
协议 域名/IP地址 端口 文件的路径 查询字符串
parse() 将URL解析为对象，可以获取各个部分

6.定时器模块(timer)
(1)一次性定时器

(2)周期性定时器

(3)立即执行的定时器

把回调函数放入到事件队列中执行，事件队列就是由一组回调函数组成的。

立即执行定时器

setImmediate( 回调函数 )
process.nextTick( 回调函数 ) 无法清除

两者都是立即执行的定时器，都是在事件队列的最前边，process.nextTick比setImmediate更先执行

文件系统模块 fs

服务器端的文件分为文件形式和目录形式

statSync同步：通过返回值获取结果
stat异步：通过回调函数来获取结果

(1)查看文件的状态
statSync(文件的路径) / stat(文件的路径, 回调函数)
isFile() 是否为文件形式
isDirectory() 是否为目录形式

//查看文件状态
//同步：通过返回值获取结果
var s=fs.statSync('../day02');
//console.log( s.isFile() );//是否为文件形式
console.log( s.isDirectory() );//是否为目录形式
console.log(s);

//异步：通过回调函数来获取结果
fs.stat('./01_homework.js',(err,s)=>{ 
  //err 可能产生的错误结果
  //s  成功获取到的结果
  if(err){
    throw err;
  }
  console.log(s);
});

(2)读取目录
readdirSync(文件的路径) / readdir(文件的路径, 回调函数)

//同步
var arr=fs.readdirSync('../day02');
console.log(arr);
//异步  readdir
fs.readdir('../day02',(err,arr)=>{
  if(err){
    throw err;
  }
  console.log(arr);
});

输出形式:

(3)创建目录
mkdirSync(文件的路径) / mkdir(文件的路径, 回调函数)

//同步创建
fs.mkdirSync('./mydir');
//异步创建mydir2   mkdir
fs.mkdir('./mydir2',(err)=>{ //失败报错显示,成功以结果形式呈现(添加目录)
  if(err) throw err;
  console.log('目录创建成功');
});

(4)移除目录
rmdirSync(文件的路径) / rmdir(文件的路径, 回调函数)

fs.rmdirSync('./mydir');
fs.rmdir('../day02',(err)=>{ //失败报错显示,成功以结果形式呈现(删除目录)
  if(err) throw err;
});

(5)覆盖写入文件
writeFileSync(文件的路径, 数据) / writeFile(文件的路径, 数据, 回调函数)
如果文件不存在，先创建文件然后写入数据
如果文件已经存在，会覆盖写入数据

fs.writeFileSync('./1.txt','ran');
fs.writeFile('./2.txt','tedu',(err)=>{
  if(err) throw err;
});

(6)追加写入文件
appendFileSync(文件的路径, 数据) / appendFile(文件的路径, 数据, 回调函数)
如果文件不存在，先创建文件然后写入数据
如果文件已经存在，会在文件的末尾追加写入数据

fs.appendFile('./3.html','WEB前端2011\n',(err)=>{
  if(err) throw err;
  console.log('文件写入成功');
});

(7)读取文件
readFileSync(文件的路径) / readFile(文件的路径, 回调函数)
格式为Buffer 不能直接显示,需要将Buffer格式转化为字符串显示

var data=fs.readFileSync('./stu.txt');
//buffer
console.log(data);
//转字符串
console.log( String(data) );

//使用异步方法读取3.html
fs.readFile('./3.html',(err,data)=>{
  if(err) throw err;
  console.log( String(data) );
});

(8)删除文件
unlinkSync(文件的路径) / unlink(文件的路径, 回调函数)

fs.unlinkSync('./1.txt');

(9)检测文件是否存在
existsSync(文件的路径)
存在 -> true 不存在 -> false

var res=fs.existsSync('../day02');
console.log(res);

(10)拷贝文件
copyFileSync(源文件路径, 目标文件路径) / copyFile(源文件路径, 目标文件路径, 回调函数)

fs.copyFileSync('./3.html','./mydir/3.txt');
fs.copyFile('./stu.txt','./mydir/stu.html',(err)=>{
if(err) throw err;
});

同步和异步

同步：会阻止后续代码的执行，先执行完当前的再往后执行，通过返回值来获取结果。
异步：不会阻止后续代码的执行，在一个独立的线程执行，通过回调函数来获取结果。

文件流

流：分段传递的
createReadStream(文件的路径) 创建可读取的文件流
createWriteStream(文件的路径) 创建可写入的文件流
on(事件名称, 回调函数) 添加事件，事件名称是固定的字符串形式
pipe() 可以将读取的流添加到写入的流

//引入fs模块
const fs=require('fs');
//创建可读取的文件流
var rs=fs.createReadStream('./1.zip');
//创建可写入的文件流
var ws=fs.createWriteStream('./mydir/2.zip');
//把读取的流通过管道添加到写入流
rs.pipe(ws);
//通过事件监听，是否有数据流入
//on(事件名称, 回调函数)  用来添加事件
//data  数据流入事件，固定的
//一旦事件被触发，通过回调函数来获取数据
var count=0;//用于记录读取的段数
rs.on('data',(chunk)=>{
  //chunk 获取到的分段数据
  //console.log(chunk);
  //每读取一段加1
  count++;
});
//console.log(count);
//监听读取结束事件
rs.on('end',()=>{
  console.log(count);
});

http协议

是客户端和web服务器之间的通信协议
(1)通用的头信息
Request URL: 请求的URL，请求的资源
Request Method: 请求的方法， get/post/delete/put…
Status Code: 响应的状态码
1**：服务器端接收到了请求，还没做出响应
2**：成功的响应
3**：响应的重定向，会跳转到另一个URL
4**：客户端请求错误
5**：服务器端错误
(2)响应的头信息 response
Content-Type：响应的内容类型， html对应 text/html
Location：设置跳转的URL
(3)请求的头信息 request
(4)请求的主体
可有可无，用于设置传递数据

http模块

用于创建web服务器

//引入http模块
const http=require('http');
//创建web服务器
const app=http.createServer();
//设置端口
app.listen(8080);

//http://127.0.0.1:8080
//http://localhost:8080

响应的对象
res.writeHead(状态码, 头信息) 设置响应的状态码和头信息
res.write() 设置响应的内容
res.end() 结束并发送响应

请求的对象
req.url 请求的URL，向服务器端请求的资源 /jianbing
req.method 请求的方法 get/post…

const http=require('http');
const fs=require('fs');
const app=http.createServer();
app.listen(8080);

//添加事件
app.on('request',(req,res)=>{
  //根据请求做出响应
  if(req.url==='/login'){
    res.writeHead(200,{
	  'Content-Type':'text/html;charset=utf-8'
	});
	res.write('<h1>这是登录的网页</h1>');
  }else if(req.url==='/study'){
    res.writeHead(302,{
	  Location: 'http://www.tmooc.cn'
	});
  }else if(req.url==='/index'){
    //读取1.html文件
	var data=fs.readFileSync('./1.html');
	//把读取到的数据响应
	res.write(data);
  }else{
    res.writeHead(404);
	res.write('not found');
  }
  //结束并发送响应
  res.end();
});

//引入express包
const express=require('express');
//console.log(express);
//创建web服务器
const app=express();
//设置端口
app.listen(8080);

//登录的路由
//请求的方法:get   请求的URL:/login
app.get('/login',(req,res)=>{
  //设置响应内容并发送
  res.send('<h1>这是登录的网页</h1>');
});
//练习：添加注册的路由
//请求的方法:get  请求的URL: /reg
//响应'<h2>请注册</h2>'
app.get('/reg',(req,res)=>{
  res.send(`
	  <h2>请注册</h2>
	  请输入用户名
  `);
});
//路由
//请求的方法:get  请求的URL:/study
app.get('/study',(req,res)=>{
  //响应的重定向
  res.redirect('http://www.tmooc.cn');
});
//练习：添加首页的路由
//请求的方法:get  请求的URL:/
//跳转到登录的路由 /login
app.get('/',(req,res)=>{
  res.redirect('/login');
});
//路由
//请求的方法:get  请求的URL:/index
app.get('/index',(req,res)=>{
  //响应文件并发送
  res.sendFile(__dirname+'/1.html');
});

console.log(__dirname);
console.log(__filename);

express框架

框架是一整套的解决方案，已有的功能进行封装简化，添加了一些没有功能。
express是一款基于Node.js平台，快速、开放、极简的WEB开发框架
网址: www.expressjs.com.cn
下载安装： npm install express
(1)创建web服务器

(2)路由
路由：服务器端根据请求的方法和请求的URL来做出特定的响应，例如注册有注册的路由，登录有登录的路由…
路由 由请求的方法、请求的URL、回调函数组成。

响应的对象
res.send() 设置响应的内容并发送
res.redirect() 设置响应的重定向，跳转到另一个URL
res.sendFile() 设置响应的文件并发送，使用文件的绝对路径 __dirname

请求的对象
req.method 获取请求的方法
req.url 获取请求的URL
req.query 获取请求中以查询字符串形式传递的数据，格式为对象

const express=require('express');
//引入查询字符串模块
const querystring=require('querystring');
const app=express();
app.listen(8080);

//响应搜索页面get  /search
app.get('/search',(req,res)=>{
  res.sendFile(__dirname+'/search.html');
});
//练习：根据表单的请求创建对应的路由(get  /mysearch)，响应'搜索成功'
app.get('/mysearch',(req,res)=>{
  //获取的请求的URL,请求的方法
  //console.log(req.url,req.method);
  //获取请求的查询字符串形式的数据
  console.log(req.query);
  res.send('搜索成功');
});
//路由 get  /login
app.get('/login',(req,res)=>{
  res.sendFile(__dirname+'/login.html');
});
//根据表单请求创建路由 post  /mylogin
app.post('/mylogin',(req,res)=>{
  //获取post传递数据,以流的方式
  //通过事件的方式，一旦数据流入，自动获取
  req.on('data',(chunk)=>{
    //console.log( chunk );
	var data=String(chunk);
	console.log(data);//查询字符串
	//引入查询字符串模块，解析为对象
    var obj=querystring.parse(data);
	console.log(obj);
  });
  res.send('登录成功');
});

//练习：添加路由(get /package)，响应'这是包的使用详情'
app.get('/package/:pname',(req,res)=>{
  //获取路由传参形式的数据
  console.log(req.params);
  res.send('这是包的使用详情');
});

(3)路由中获取数据

路由器

把同一个模块下的所有路由放到一起，最终挂载到web服务器，可以给同一个模块下所有的URL添加统一的前缀。


练习：创建用户路由器模块user.js，创建路由器，添加路由(get /user)，导出路由器；在web服务器下引入并挂载，添加前缀 /v1/user

const express=require('express');
//创建路由器对象
const r=express.Router();
//添加路由
//用户列表(get /list)
r.get('/list',(req,res)=>{
  res.send('这是用户列表');
});
//导出路由器
module.exports=r;

//引入express
const express=require('express');
//创建路由器对象
const r=express.Router();
//往路由器中添加路由
//商品列表 get /list
r.get('/list',(req,res)=>{
  res.send('这是商品列表');
});
//导出路由器对象
module.exports=r;

const express=require('express');
//引入商品路由器模块
const productRouter=require('./router/product.js');
//引入用户路由器模块
const userRouter=require('./router/user.js');
//console.log(productRouter);
const app=express();
app.listen(8080);

//将路由器挂载到web服务器
app.use('/v1/product',productRouter);
app.use('/v1/user',userRouter);

中间件

拦截对服务器的请求，按照URL拦截
分为应用级中间件、路由级中间件、内置中间件、第三方中间件、错误处理中间件
(1)应用级中间件
也称为自定义的中间件，是一个函数
app.use( URL, 回调函数 ) 一旦拦截到URL，调用回调函数

练习：创建添加到购物车的路由(get /shopping)，添加中间件拦截对添加到购物车的请求，在中间件实现传递价格(price)打九折，最后在路由中响应

const express=require('express');
const app=express();
app.listen(8080);
//拦截购物车的请求
app.use('/shopping',(req,res,next)=>{
  console.log(req.query);
  //将价格打九折
  req.query.price*=0.9;
  //赠送礼物，往请求的数据中添加内容
  req.query.gift='一棵圣诞树';
  //往后继续执行
  next();
});
//添加到购物车(get  /shopping)
app.get('/shopping',(req,res)=>{
  console.log(req.query);
  res.send('商品的价格：'+req.query.price);
});

(2)路由级中间件
路由器的使用
app.use( URL, 引入的路由器 )

(3)内置中间件
express中提供好的，可以直接拿来用的
静态资源：html、css、js、图像、…
托管静态资源，当浏览器端请求静态资源，服务器端不需要创建路由，而是由让浏览器端自动的到指定的目录下查找。
app.use( express.static(‘目录的路径’) )

(4)第三方中间件
属于第三方模块的形式，需要下载安装
body-parser中间件的用法
用于将post请求的数据(流)解析为对象
npm install body-parser 下载安装

const express=require('express');
//const querystring=require('querystring');
//1.引入body-parser中间件模块
const bodyParser=require('body-parser');
const app=express();
app.listen(8080);
//托管静态资源到public目录
app.use( express.static('./public') );
//2.将所有post请求的数据(流)解析为对象
app.use( bodyParser.urlencoded({
  extended:false  //是否使用第三方的查询字符串模块
}) );
//创建路由(post /mylogin)，接收表单的请求
app.post('/mylogin',(req,res)=>{
  /*
  //获取以流的方式传递的数据
  req.on('data',(chunk)=>{
	//格式为查询字符串
    var str=String(chunk);
	console.log(str);
	//解析为对象
	var obj=querystring.parse(str);
	console.log(obj);
  });
  */
  //3.获取post请求的数据
  console.log(req.body);
  res.send('登录成功 驲');
});

静态资源

成功页面显示

mysql模块

连接
mysql.exe -h127.0.0.1 -P3306 -uroot -p
mysql -uroot
mysql -uroot<拖拽文件 回车
show databases;
use 数据库名称;
show tables;
desc 表名称;
quit;
insert into emp values(…);
delete from emp where eid=1;
update emp set sex=1,salary=8000 where eid=2;
select * from emp;

属于第三方模块，需要下载安装
npm install mysql
createConnection() 创建连接对象
connect() 执行连接
query(sql命令, 回调函数) 执行SQL命令，通过回调函数获取结果

//引入mysql模块
const mysql=require('mysql');
//创建连接对象
const c=mysql.createConnection({
  host:'127.0.0.1',
  port:'3306',
  user:'root',
  password:'',
  database:'tedu'
});
//执行连接
//c.connect();
//执行SQL命令，查询出所有员工的编号和姓名
c.query('select eid,ename from emp where ename="ran"',(err,result)=>{
  //err:可能产生的错误
  if(err) throw err;
  //result: SQL命令的结果
  console.log(result);
});

SQL注入

select * from emp where ename=‘ran’ or 1=1;
query(’ select * from emp where ename=?’,[obj.ename],回调函数)
占位符(对数据进行过滤，过滤后去替换占位符)
select * from emp where salary>=? and salary<=?
SQL注入总结

连接池

RESTfu

l：接口设计规范，属于一种风格；

URL：对应请求的资源
http://www.codeboy.com:9999/mysearch?ename=ran
协议 域名/IP地址 端口 路由 查询字符串

路由格式
/版本号/资源/资源的编号
/v1/emps/1
/v1/emps?s1=5000
/v1/users/3
/v1/users/checkuname
请求的方法
get post
插入数据 post
删除数据 delete
修改数据 put
查询数据 get
返回结果
json对象
{“code”:“状态码”, “msg”:“消息内容”}
{“code”:200, “msg”: data: [] }

const express=require('express');
const bodyParser=require('body-parser');
const mysql=require('mysql');
const app=express();
app.listen(8080);
//创建连接池对象
const pool=mysql.createPool({
  host:'127.0.0.1',
  port:'3306',
  user:'root',
  password:'',
  database:'tedu',
  connectionLimit:'20'
});
//使用body-parser中间件，将post请求的数据解析为对象
app.use( bodyParser.urlencoded({
  extended:false
}) );
//练习：添加员工的路由( post  /v1/emps ),响应'添加成功'；
app.post('/v1/emps',(req,res)=>{
  //1.接收post传递(流)数据，使用中间件body-parser
  console.log(req.body);
  var obj=req.body;
  //2.判断各项是否为空
  if(!obj.ename){
    res.send({code:401,msg:'ename不能为空'});
	//跳出函数
	return;
  }
  if(!obj.sex){
    res.send({code:402,msg:'sex不能为空'});
	return;
  }
  if(!obj.birthday){
    res.send({code:403,msg:'birthday不能为空'});
	return;
  }
  if(!obj.salary){
    res.send({code:404,msg:'salary不能为空'});
	return;
  }
  if(!obj.deptId){
    res.send({code:405,msg:'deptId不能为空'});
	return;
  }
  //3.将数据插入到数据表emp中
  pool.query('insert into emp set ?',[obj],(err,result)=>{
    if(err){
	  res.send({code:500,msg:'服务器端错误'});
	  return;
	}
	console.log(result);
	//成功
	res.send({code:200,msg:'员工添加成功'});
  });
  //{"code":"状态码", "msg":"消息内容"}
});

//2.删除员工
//http://127.0.0.1:8080/v1/emps/5  delete
app.delete('/v1/emps/:eid',(req,res)=>{
  //2.1 获取路由传参的数据
  var obj=req.params;
  console.log(obj);
  //2.2判断编号是否为空
  if(!obj.eid){
    res.send({code:401,msg:'eid不能为空'});
	return;
  }
  //2.3执行SQL命令
  pool.query('delete from emp where eid=?',[obj.eid],(err,result)=>{
    if(err){
	  res.send({code:500,msg:'服务器端错误'});
	  return;
	}
	console.log(result);
	//如果result下的affectedRows属性为0说明删除失败，否则删除成功
	if(result.affectedRows===0){
	  res.send({code:201,msg:'删除失败'});
	}else{
	  res.send({code:200,msg:'删除成功'});
	}
  });
});

数据接口(API)

1.项目目录结构

pool.js

const mysql=require('mysql');
//创建连接池对象
const pool=mysql.createPool({
  host:'127.0.0.1',
  port:'3306',
  user:'root',
  password:'',
  database:'xz',
  connectionLimit:'20'
});
//导出连接池对象
module.exports=pool;

user.js

const express=require('express');
//引入连接池模块
const pool=require('../pool.js');
//创建路由器对象
const r=express.Router();
//1.用户注册(post /reg)
r.post('/reg',(req,res)=>{
  //1.1获取post请求的数据
  var obj=req.body;
  console.log(obj);
  //1.2验证各项数据是否为空
  var i=400;
  for(var k in obj){
	i++;
    if(!obj[k]){
	  res.send({code:i,msg:k+'不能为空'});
	  return;
	}
  }
  //1.3执行SQL命令，将数据插入到数据表
  pool.query('insert into xz_user set ?',[obj],(err,result)=>{
    if(err){
	  console.log(err);
	  res.send({code:500,msg:'服务器端错误'});
	  return;
	}
	res.send({code:200,msg:'注册成功'});
  });
});
//2.用户登录(post /login)
r.post('/login',(req,res)=>{
  //2.1获取post请求的数据
  var obj=req.body;
  console.log(obj);
  if(!obj.uname){
    res.send({code:401,msg:'uname不能为空'});
	return;
  }
  if(!obj.upwd){
    res.send({code:402,msg:'upwd不能为空'});
	return;
  }
  //2.3执行SQL命令
  pool.query('select * from xz_user where uname=? and upwd=?',[obj.uname,obj.upwd],(err,result)=>{
    if(err){
	  console.log(err);
	  res.send({code:500,msg:'服务器端错误'});
	  return;
	}
	console.log(result);
	//返回结果为数组，如果数组长度为0说明登录失败，否则登录成功
	if(result.length===0){
	  res.send({code:201,msg:'登录失败'});
	}else{
	  res.send({code:200,msg:'登录成功'});
	}
  });
});
//3.修改用户资料(put /编号)
r.put('/:uid',(req,res)=>{
  //3.1获取传递的数据
  var obj1=req.params;//路由传参
  var obj2=req.body;//body传递
  console.log(obj1,obj2);
  //3.2验证数据是否为空
  var i=400;
  for(var k in obj2){
	i++;
    if(!obj2[k]){
	  res.send({code:i,msg:k+'不能为空'});
	  return;
	}
  }
  //3.3执行SQL命令，修改数据
  pool.query('update xz_user set ? where uid=?',[obj2,obj1.uid],(err,result)=>{
    if(err){
	  console.log(err);
	  res.send({code:500,msg:'服务器端错误'});
	  return;
	}
    console.log(result);
	//通过result下的affectedRows判断是否成功，如果是0表示失败
	if(result.affectedRows===0){
	  res.send({code:201,msg:'修改失败'});
	}else{
	  res.send({code:200,msg:'修改成功'});
	}
  });
});
//4.用户列表(get /)
r.get('/',(req,res)=>{
  //4.1获取查询字符串传递的数据
  var obj=req.query;
  console.log(obj);
  //4.2验证是否为空
  if(!obj.pno) obj.pno=1;
  if(!obj.count) obj.count=2;
  console.log(obj);
  //4.3计算开始查询的值
  var start=(obj.pno-1)*obj.count;
  //4.4将每页的数据量强制转为整型
  var size=parseInt(obj.count);
  //4.5执行SQL命令
  pool.query('select uid,uname from xz_user limit ?,?',[start,size],(err,result)=>{
    if(err){
	  console.log(err);
	  res.send({code:500,msg:'服务器端错误'});
	  return;
	}
	res.send({code:200,msg:'查询成功',data:result});
  });
});

//导出路由器对象
module.exports=r;

app.js

const express=require('express');
//引入用户路由器
const userRouter=require('./router/user.js');
//引入body-parser中间件模块
const bodyParser=require('body-parser');
//创建WEB服务器
const app=express();
//设置端口
app.listen(8080);
//使用body-parser中间件，将post请求的数据解析为对象
app.use(bodyParser.urlencoded({
  extended:false
}));
//挂载路由器，添加前缀/v1/users
app.use('/v1/users',userRouter);
// http://127.0.0.1:8080/v1/users/reg