nodejs

1.概述

nodejs基于谷歌V8引擎，运行在服务器端的语言，基于JS
nodejs.org——英文官网； nodejs.cn——中文网

对比JS和nodejs
JavaScript：1.客户端技术，运行于浏览器中；
2.有多种解释器可以使用，如IE的Chakra，FF的猴子系列，Chrome的V8等等；
3.因为解释器有多种，所以存在代码兼容性问题；
4.支持ES对象，自定义对象，BOM&DOM对象；
5.主要用于网页DOM元素的操作，实现用户交互效果。
Node.js：1.服务器端技术，与PHP，JSP等是类似的技术；
2.只能运行于基于V8引擎改进而来的运行时环境；
3.只有一种解释器，所以不存在代码兼容性问题；
4.支持ES对象，自定义对象，Node.js扩展对象（大量）；
5.主要用于实现服务器端运行逻辑，如文件系统操作，数据库访问，其他服务器调
用等

node.js的特点
1.简单，避免过度设计
2.单线程逻辑处理
3.非阻塞的异步I/O处理
4.事件驱动编程
5.无锁机制，不会产生死锁
6.支持数万个并发连接
7.nodejs适合搭建以IO操作为主，响应速度快，易于扩展的网络应用，应用场景例如：
命令行工具；带有GUI界面的本地应用程序；交互式终端程序；单元测试工具；基于社交网络
的大规模Web应用；Web Socket服务器；TCP/UDP套接字程序；客户端Javascript编译器
8.nodejs不适合CPU密集型应用，例如：
深层次的嵌套和递归；复杂加密和解密算法；高可靠性运算；严格内存管理；数据挖掘和数据
分析
9.nodejs与Java/PHP/.NET等技术属于同类，都是运行于服务器端的技术，而与客户端JS仅仅
是语法相同，功能完全不同
10.nodejs适合于IO密集型的应用，而不适合于CPU密集型的应用

脚本模式：node c:/xampp/…/1.js（拖进文件路径）
交互模式：node 回车 进入交互模式
两次ctrl+c 或者 .exit 退出交互模式

2.nodejs中的对象

1.全局对象
全局作用域下的变量就是全局对象下的属性，全局对象下的函数就是全局对象下的方法，可以使用
全局对象来访问。
（1）nodejs:global
在交互模式下，声明的变量和创建的函数都属于全局下的，可以使用global来访问；
在脚本模式下，声明的变量和创建的函数都不属于全局下的，一个文件默认会创建一个独立的作用
域，叫做文件（模块）作用域。防止污染全局。
//局部的
var a=1;
function fn(){
console.log(2);
}
//使用global来访问a和fn.//结果不存在，说明脚本下的变量以及函数都不是global1下的
console.log(global.a);//不可访问
global.fn();//不可访问
（2）js:window
在浏览器下，文件中声明的变量或者创建的函数都属于是全局作用域下的，会污染全局。
var a=1;
function fn(){
console.log(2);
}
//使用全局对象来访问
console.log(window.a);
window.fn();

2.console对象——控制台
global.console.log()——打印日志
global.console.info()——打印消息
global.console.warn()——打印自定义的警告
global.console.error()——打印自定义的错误
检测程序的耗时：global.console.time(‘自定义字符串’)——开始计时
global.console.timeEnd(‘自定义字符串’)——结束计时
自定义字符串前后保持一致
global.console.log(1);//打印日志
global.console.info(2);//打印消息
global.console.warn(3);//打印自定义的警告
global.console.error(4);//打印自定义的错误
//检测程序的耗时
global.console.time(‘for’);//开始计时
for(var i=1;i<=100;i++){

}
global.console.timeEnd(‘for’);//结束计时

//练习：计时查看for,while,dowhile循环10000的耗时
//while循环
global.console.time(‘while’);
var i=1;
while(i<=10000){
i++;
};
global.console.timeEnd(‘while’);
//dowhile循环
global.console.time(‘dowhile’);
var i=1;
do{
i++;
}while(i<=10000);
global.console.timeEnd(‘dowhile’);

3.process对象——进程（在服务器端编辑）
process.arch——查看当前CPU的架构
process.platform——查看当前的操作系统
process.env——查看当前系统的环境变量
process.version——查看当前nodejs的版本号
process.pid——查看当前的进程编号
process.kill()——结束某个编号的进程

4.Buffer对象——缓冲区
一块用于临时存储数据的内存区域，可以存储文件数据，网络上传输的资源（视频，在线直播…)
var buf=Buffer.alloc(5,‘abcde’)——创建Buffer
<Buffer 61 62 63 64 65>——buffer数据
buf.toString()——将buffer数据转为字符串
//创建buffer
var buf=global.Buffer.alloc(5,‘abcde’);
console.log(buf);//<Buffer 61 62 63 64 65>
console.log(buf.toString());

3.定时器

1.一次性定时器
var timer=setTimeout(回调函数,间隔的时间);——开启:当间隔的时间到了,执行回调函数,单位毫秒
clearTimeout(timer);——清除
//一次性定时器
var timer=global.setTimeout(function(){
console.log(‘炸弹爆炸’);
},3000);
//清除一次性定时器
global.clearTimeout(timer);

2.周期性定时器
var timer=setInterval(回调函数,间隔的时间);——每隔一段时间，执行一次回调函数
clearInterval(timer);——清除
//周期性定时器
var timer=setInterval(()=>{
console.log(‘滴滴滴滴’);
},3000);
//清除周期定时器
clearInterval(timer);

//练习：使用周期性定时器每隔3秒钟打印hello，打印三次以后，清除定时器
var i=0;
var timer=setInterval(function(){
console.log(‘hello’);
//次数加1
i++;
//当i为3的时候，清除定时器
if(i==3){
clearInterval(timer);
}
},3000);

3.立即执行定时器
var timer=setImmediate(回调函数)——回调函数会放入到队列中，当主线程程序执行完，才会执
行队列中的内容
clearImmediate(timer)——清除
process.nextTick(回调函数)——在主程序的末尾执行
//立即执行定时器
var timer=setImmediate(function(){
//回调函数会放入到队列中
//当主线程执行完，才会执行队列的内容
//console.log(1);
console.log(‘查询数据’);
});
clearImmediate(timer);

//在主程序执行完，立即执行
process.nextTick(function(){
console.log(‘操作数据-2’);
});

//连接数据库
console.log(‘连接数据库’);

4.模块

模块就是一个封装好的功能体
在nodejs下模块分为自定义模块，核心模块（官方提供），第三方模块

1.自定义模块
在nodejs下，任意一个js文件都是一块模块，文件中的代码默认被一个构造函数所包含
(function(exports,require,module,__filename,__dirname){
//程序员编写的代码
})
__filename 当前模块的完整路径和文件名称
__dirname 当前模块的完整路径
require() 引入一个模块
module 指代当前的模块对象
module.exports 当前模块导出的对象，包含供其它模块使用的属性和方法
exports===module.exports

//当前模块
//(function(exports,require,module,__filename,__dirname){ })
//当前模块的完整路径和文件名称
console.log(__filename);
//当前模块的完整路径 dir->directory目录
console.log(__dirname);
//引入模块07_2.js
// ./ 同一级目录
//把07_2.js模块导出的结果放入到变量中
var obj=require(’./07_2.js’);
console.log(obj);
console.log(obj.mya);

//练习：在07_2.js声明变量b，创建函数fn，导出变量和函数
console.log(obj.b);
//调用函数fn
obj.fn();

//主要模块，引入circle.js
//.js后缀名可以省略
var circle=require(’./01_circle’);
console.log(circle);
//调用两个函数
// console.log(circle.getLength(5).toFixed(1));
// console.log(circle.getArea(5).toFixed(1));
//circle.fn();

//引入的模块
console.log(‘07_2.js’);
var a=1;
//导出：公开哪些变量或者函数
//默认导出的是一个空对象
//添加导出的内容，就是往导出的对象中添加属性和方法
//module 指代当前的模块对象
//module.exports 导出的对象
module.exports.mya=a;

//练习：在07_2.js声明变量b，创建函数fn，导出变量和函数
var b=2;
function fn(){
console.log(3);
}
module.exports.b=b;
module.exports.fn=fn;

//功能模块
function getLength®{
return 2rMath.PI;
}
function getArea®{
return Math.pow(r,2)*Math.PI;
}
//导出两个函数
// module.exports.getLength=getLength;
// module.exports.getArea=getArea;
// module.exports.fn=function(){
// console.log(1);
// }
//module.exports导出对象
//赋值对象给要导出的对象，exports和module.exports就不再指向同一个对象了
module.exports={
eid:1,
ename:‘tom’,
sex:‘男’
}
//false
console.log(module.exports===exports);

2.模块分类
引入的文件名为index.js，不需要创建packge.json文件。否则需要创建packge.json文件，并在该
文件中写入{ “main”: “文件名.js” }
以路径开头
不以路径开头
文件模块
require(’./circle.js’)常用于用户自定义的模块，如果后缀名是js，则可以省略
require(‘url’)用于引入官方提供了核心模块
目录模块
require(’./02_2’)在02_2目录下寻找packge.json中寻找main属性对应的文件，找不到会去引入index.js
require(‘04_2’)自动到当前目录下的node_modules中寻找目录模块04_2，如果找不到会到上一级目录下寻找，直到顶级目录。常用于第三方模块

3.npm和包
包(package)：是一个目录模块，里边包含多个文件，其中有一个文件命名为package.json，是包
说明文件，含有包的信息
npm：包管理工具，安装nodejs的时候会附带安装，用于管理包，包括下载，上传，升级…
下载地址：npm官网 www.npmjs.com
（1）切换目录
cd 完整路径
如果要进入其他的盘符——命令行中输入d: 回车
进入指定目录下，按住shift键，在空白区域单击鼠标右键->在此处打开powershell
（2）使用npm下载安装第三方包
npm install 包名称——服务器端输入
（3）生成package.json
npm init -y 自动生成一个package.json文件，后期使用npm安装的包都会记录到这个文件中。
npm install 自动安装package.json文件中记录的包

4.querystring模块——引入require(‘querystring’)
属于核心模块，nodejs官方提供的，可以直接引入，不需要创建
www.codeboy.com/detail.html?lid=5&name=dell
浏览器向服务器发请求，传递数据的一种方式
parse()——将查询字符串格式化为对象
stringify()——将对象转换成查询字符串
//引入querystring模块
const querystring=require(‘querystring’);
//查询字符串
var str=‘lid=5&name=dell’;
//使用查询字符串模块，将查询字符串格式化为对象
var obj=querystring.parse(str);
console.log(obj);
//将对象转换成查询字符串
var str2=querystring.stringify(obj);
console.log(str2);

//练习：获取百度查询中查询字符串中的关键字
var str=‘e=utf-8&tn=baidu&wd=电脑’;
var obj=querystring.parse(str);
console.log(obj.wd);

5.url模块——引入require(‘url’)
parse()——将url格式化为对象
format()——将对象转为url，创建时内容如下：
protocol 协议
hostname 服务器域名/IP地址
port 端口号
pathname 文件在服务器上的路径
query 查询字符串，属性对应的是对象
//引入url模块
const url=require(‘url’);
//url
var str=‘http://www.codeboy.com:80/product/detail.html?lid=5&name=dell’;
//将url格式化为对象
var obj=url.parse(str);
console.log(obj);
//将对象转换成url
var obj={
protocol:‘http’,
hostname:‘172.163.0.224’,
port:8080,
pathname:’/admin/login.html’,
//search:’?uname=root&upwd=123456’
query:{
uname:‘root’,
upwd:‘123456’
}
}
var str=url.format(obj);
console.log(str);

//练习：获取浏览器中传递数据
const url=require(‘url’);
const querystring=require(‘querystring’);
var str=‘https://www.tmooc.cn:3000/web/1903.html?sid=10&course=javascript’;
var obj=url.parse(str);
var qs=obj.query;
//将查询字符串格式化为对象
var obj2=querystring.parse(qs);
console.log(obj2.sid,obj2.course);

6.fs模块——文件系统模块，引入require(‘fs’)
用于文件的操作，目录的创建，删除，读取；文件的创建，读取，写入，删除…
（1）查看文件的状态
1）异步：方法调用后，无序等待结束，直接去执行后续的代码，整个过程，不会阻碍后边的任
务；通过回调函数获取结果fs.stat(path,callback)
path：要查看的文件的路径；
callback：回调函数，用于获取文件的状态
callback回调函数：function(err,stats){ if(err) throw err; stats.isDirectory(); stats.isFile(); }
err：如果查看失败的错误信息；
stats：文件的状态信息；
throw：抛出错误，阻止往后执行
isDirectory()：是否为目录；
isFile()：是否为文件

//引入文件系统模块
const fs=require(‘fs’);
//查看文件的状态
//参数1：要查看的文件路径
//参数2：回调函数，用于获取结果
fs.stat(‘08_url.js’,function(err,stats){
//err:如果查看失败的错误信息
//throw抛出错误，阻止往后执行
if(err) throw err;
//stats:文件的状态信息
console.log(stats);
//是否为目录
console.log(stats.isDirectory());
//是否为文件
console.log(stats.isFile());
});
2）同步：方法调用后，必须等待方法调用结束，才能继续后边的任务；通过返回值获取结果
statSync(path)
//引入fs模块
const fs=require(‘fs’);
//异步方法
fs.stat(‘01_homework’,function(err,stats){
if(err) throw err;
console.log(stats);
})
//把查看的文件状态保存到了变量中
//使用方法的返回值获取结果
//同步方法
var stats=fs.statSync(‘01_homework’);
console.log(stats);

（2）创建目录
异步：fs.mkdir(path,callback)
fs.mkdir(’./mydir’,function(err){
if(err) throw err;
//其他的后续操作
console.log(‘目录创建成功’);
});

同步：mkdirSync(path)
fs.mkdirSync(‘mydir3’);

（3）移除目录
异步：fs.rmdir(path,callback)
fs.rmdir(‘mydir3’,function(err){
if(err) throw err;
console.log(‘移除成功’);
});

同步：rmdirSync(path)
fs.rmdirSync(‘mydir3’);

（4）读取目录
异步：fs.readdir(path,callback)
callback回调函数：function(err,files){ if(err) throw err; }
err：可能产生的错误信息；
files：读取的结果，格式为数组；

fs.readdir(‘01_homework’,function(err,files){
if(err) throw err;
//files是读取的结果
console.log(files);
});
同步：readdirSync(path)
var files=fs.readdirSync(‘01_homework’);
console.log(files);

（5）清空写入
如果文件不存在会创建文件，如果文件已经存在，会清空文件中的内容，然后写入
异步：fs.writeFile(path,data,callback)/同步：writeFileSync()
异步注释：path：要写入的文件的路径； data：要写入的数据； callback：回调函数

fs.writeFile(‘1.txt’,‘tedu’,function(err){
if(err) throw err;
console.log(‘写入文件’);
});

（6）追加写入
如果文件不存在会创建文件，如果文件存在，在文件的末尾写入数据
异步：fs.appendFile(path,data,callback)/同步：appendFileSync()
fs.appendFile(‘2.txt’,‘tedu\n’,function(err){
if(err) throw err;
console.log(‘写入文件’);
});

//练习：创建数组，包含多个姓名，遍历数组获取每个元素，把每个元素使用同步方法写入到文件data.txt
//创建数组
var arr=[‘tom’,‘jerry’,‘kate’];
//遍历数组,获取每个元素
for(var i=0;i<arr.length;i++){
//把每个元素写入到文件中
fs.appendFileSync(‘data.txt’,arr[i]+’\n’);
}

（7）读取文件
异步：fs.readFile(path,callback)/同步：readFileSync()
异步callback回调函数：function(err,data){ if(err) throw err; data.toString() }
err：可能产生的错误信息；
data：读取的文件中的数据，格式为buffer；

fs.readFile(‘1.txt’,function(err,data){
if(err) throw err;
console.log(data.toString());
});

（8）删除文件
异步：fs.unlink(path,callback)/同步：unlinkSync()
fs.unlink(‘1.txt’,function(err){
if(err) throw err;
});

(9)判断文件(目录)是否存在
fs.existsSync(path) 存在->true 不存在->false
var res=fs.existsSync(‘1.txt’);
console.log(res);

//练习：判断文件2.txt是否存在，如果存在删除
if(fs.existsSync(‘2.txt’)){
fs.unlinkSync(‘2.txt’);
}
//练习：判断目录mydir2是否存在，如果不存在创建
if(!fs.existsSync(‘mydir2’)){
fs.mkdirSync(‘mydir2’);
}

5.http协议

1.http协议是浏览器和web服务器之间的通信协议
（1）通用头信息(General)
Request URL：请求的URL，对应浏览器地址栏的内容，要向服务器获取哪些内容。
Request Method：请求的方法，GET/POST…，获取内容的方式。
Status Code：响应的状态码，可以查看到响应的结果。
1**：正在请求，没有结束
2**：成功的响应
3**：响应的重定向，跳转到另一个URL；通常结合响应头信息中Location一起使用
4**：客户端错误
5**：服务器错误
Remote Address：请求的服务器的IP地址和端口号
（2）响应头信息(ResponseHeaders)
Connection：连接的方式，keep-alive持续连接
Content-Type：响应的文件类型
Content-Length：响应的文件长度
Transfer-Encoding：传输方式 chuncked 分段传输
Content-Encoding：压缩模式 gzip
Location：当响应重定向的时候，跳转的URL
（3）请求头信息(RequestHeaders)
Accept：客户端接受的文件类型有哪些
Accept-Encoding：客户端接受的压缩形式
User-Agent：客户端发请求使用的浏览器
（4）请求主体
可有可无，客户端向服务器端传递的数据

2.http模块
既可以模拟浏览器向web服务器发请求，也可以创建web服务器
（1）模拟浏览器
http.get(url,callback)
get：请求的方法
callback：回调函数，用于获取服务器端的响应
callback回调函数：function(res){ res; res.statusCode; res.on(‘data’,function(buf){ }); }
res：响应的对象
statusCode：响应的状态码
res.on(‘data’,function(buf){ })：通过事件获取服务器端的响应，当有数据传输的时候自动触发；通
过回调函数来接收数据；buf就是传输的数据，格式为buffer

//引入http模块
const http=require(‘http’);
//模拟浏览器向web服务器发请求
//get：请求的方法
//参数1：请求的URL
//参数2：回调函数，用于获取服务器端响应
http.get(‘http://www.baidu.com’,function(res){
//res：响应的内容，格式为对象
console.log(res);
//响应的状态码
console.log(res.statusCode);
//响应的数据
//通过事件获取：当有数据传输的时候，自动触发这个事件
//使用回调函数来接收
res.on(‘data’,function(buf){
console.log(buf.toString());
});
});

//练习：使用http模块下的get方法向http://www.tmooc.cn发送请求，并获取响应的数据
http.get(‘http://www.tmooc.cn’,function(res){
console.log(res.statusCode);
res.on(‘data’,function(buf){
console.log(buf.toString());
});
});

http.get(‘http://www.weather.com.cn/data/sk/101010100.html’,function(res){
console.log(res.statusCode);
res.on(‘data’,function(buf){
console.log(buf.toString());
});
});
（2）创建web服务器
var server=http.createServer()：创建web服务器
server.listen(8080)：设置web服务器端口号，监听端口变化
server.on(‘request’,function(req,res){ })：接收浏览器的请求是一个事件,当有请求时自动触发
req：请求的对象
res：响应的对象
url：请求的URL，显示端口后的部分
method：请求的方法
writeHead(code,obj)：设置响应状态码和头信息
code：状态；obj：是一个头信息的对象
write()：设置响应的内容
end()：结束响应，发送响应的内容到浏览器

//引入http模块
const http=require(‘http’);
//创建web服务器
var server=http.createServer();
//设置web服务器的端口号，监听端口变化
server.listen(8080);
//接收浏览器的请求
//on 是一个事件，当有请求发生自动触发
//参数1：request事件名称（请求）
//参数2：通过回调函数来获取请求和做出响应
server.on(‘request’,function(req,res){
//req：请求的对象
//请求的URL
console.log(req.url,req.method);
//res：响应的对象
//设置响应的状态码和头信息
res.writeHead(200,{
Server:‘web1903’
});
//设置响应的状态码为302，跳转到学子商场
res.writeHead(302,{
Location:‘http://www.codeboy.com’
});
//设置响应的内容
res.write(‘this is homepage’);
//练习：当请求的url为/login，响应一句话‘login’，当请求的url为/study，跳转到http://www.tmooc.cn
if(req.url==’/login’){
res.write(‘login’);
}else if(req.url==’/study’){
res.writeHead(302,{
Location:‘http://www.tmooc.cn’
});
};
//结束响应，发送响应的内容到浏览器
res.end();
});

//练习：使用http模块创建web服务器，设置端口8080；接收浏览器的请求
// /login 响应 this is login page
// /member 响应 welcome to home
// / 重定向 /login
//以上都没有 响应内容 404 not found

const http=require(‘http’);
//创建web服务器
var server=http.createServer();
//设置端口
server.listen(8080);
//接收浏览器的请求
server.on(‘request’,function(req,res){
console.log(req.method,req.url,req.headers);
//根据不同的请求的url做出响应
if(req.url==’/login’){
res.write(‘this is login page’);
}else if(req.url==’/member’){
res.write(‘welcome to home’);
}else if(req.url==’/’){
res.writeHead(302,{
Location:’/login’
});
}else{
res.writeHead(404,{});
res.write(‘404 not found’);
};
//结束并发送响应
res.end();
})

3.使用zlib模块对文件压缩
const zlib=require(‘zlib’); //引入压缩模块
Content-Encoding:gzip //告诉浏览器内容为 gzip 压缩，收到以后会进行解压缩
let gzip=zlib.createGzip(); //创建 gzip压缩
fs.createReadStream(文件路径).pipe(gzip)
.pipe(res); //以流的方式读取文件并添加到压缩，把压缩响应到浏览器

6.express框架

express框架是基于nodejs的，快速，开发，极简的web开发框架
www.expressjs.com.cn 命令行安装 npm install express

//引入express
const express=require(‘express’);
//创建web服务器
var server=express();
//设置端口
server.listen(8080);

1.路由
浏览器向web服务器发送请求，web服务器根据请求的方法和请求的URL来做出响应。
三要素：请求方法，请求的URL，响应（回调函数）
（1）响应的对象(res)
send()：响应内容，只能响应一次
sendFile()：响应文件，必须使用绝对路径(__dirname)
redirect()：响应的重定向
//路由
//get：请求的方法
//参数1：请求的URL
//参数2：响应
server.get(’/index’,function(req,res){
//req：请求的对象
//res：响应的对象
res.send(‘这是首页’);
});
//练习：创建路由，请求方法为get，请求的URL：/login，响应 ‘请登录’
server.get(’/login’,function(req,res){
//send调用一次，就代表响应结束；就不允许再次响应。
res.send(请登录<br> 欢迎);
});
//练习：创建路由，请求方法get，请求url：/list，响应内容‘这是商品列表’
server.get(’/list’,function(req,res){
//res.send(‘这是商品列表’);
//响应list.html文件到浏览器
res.sendFile(__dirname+’/list.html’);
});
//请求方法：get，请求URL：/study，响应中跳转到http://www.tmooc.cn
server.get(’/study’,function(req,res){
//跳转
res.redirect(‘http://www.tmooc.cn’);
});

//路由1
server.get(’/index’,function(req,res){
res.send(‘这是首页’);
});
//路由2
server.get(’/login’,function(req,res){
res.sendFile(__dirname+’/login.html’);
});
//路由3
server.post(’/reg’,function(req,res){
res.send(‘欢迎注册’);
});
//路由4
server.get(’/’,function(req,res){
res.redirect(’/index’);
});
（2）请求的对象(req)
req.method：请求的方法
req.url：请求的URL
req.headers：请求的头信息
req.query：获取请求时查询字符串传递的数据，并格式化为对象
server.get(’/list’,function(req,res){
console.log(req.method,req.url);
console.log(req.headers);//头信息
//获取url中查询字符串，并将它转为对象
console.log(req.query);
res.send(‘这是商品的列表’);
});

2.传递数据方式
（1）post
post请求是通过表单提交(暂时)传递数据,服务器端是通过事件的形式获取数据(后期会有简单的方法)
req.on(‘data’,function(buf){ });
buf就是获取的数据，格式为buffer，转为字符串后格式为查询字符串，需要借助查询字符串模块格
式化为对象
js文件：post发送请求
const express=require(‘express’);
//引入查询字符串模块
const querystring=require(‘querystring’);
//创建web服务器
var server=express();
//设置端口8080
server.listen(8080);
server.get(’/reg’,function(req,res){
res.sendFile(__dirname+’/reg.html’);
});
//根据表单的请求添加对应的路由
//post /myreg
server.post(’/myreg’,function(req,res){
//获取post请求传递的数据
//以事件的形式
//当有数据传输自动触发事件
//使用回调函数接收数据
req.on(‘data’,function(buf){
//buf传递的数据,是buffer形式
//console.log(buf.toString());
//查询字符串
var str=buf.toString();
//查询字符串(querystring)格式化为对象
var obj=querystring.parse(str);
console.log(obj);
});
res.send(‘注册成功’);
});
html文件：表单

请注册

//form用于表单提交（向服务器发请求） //method：设置请求的方法 //action：设置请求的URL //name：给当前输入的文本框起名字，用于服务器端接收 用户：
密码：
手机：

（2）get
get请求以查询字符串形式传递数据，服务器端使用req.query获取数据，结果为对象。
查询字符串传递数据容易被浏览器所缓存，而post传递数据不会出现在地址栏。
js文件：get发送请求
// get /login login.html
server.get(’/login’,function(req,res){
res.sendFile(__dirname+’/login.html’);
});
//根据表单的请求创建对应的路由
//get /mylogin
server.get(’/mylogin’,function(req,res){
//获取get请求传递数据
console.log(req.query);
res.send(‘登录成功’);
});
html文件：表单

请登录

用户：
密码：

（3）使用路由传递数据——路由传参
设置路由中接收的名称 :lid
server.get(’/detail/:lid’,function(req,res){
req.params //获取路由传递的数据，格式为对象
});
浏览器传递：http://127.0.0.1:8080/detail/5
说明：5就是传递的数据，使用lid来接收

server.get(’/detail/:lid’,function(req,res){
//接收路由传递的数据
console.log(req.params);
res.send(‘商品详情’);
});
//购物车路由
server.get(’/shopping/:pname/:price’,function(req,res){
console.log(req.params);
res.send(‘这是购物车’);
});

3.对比get和post请求
传递方式
获取方式
其他
get
查询字符串(可见，容易被浏览器缓存)
req.query
速度快，安全性相对低，数据量小
post
请求主体(不可见)
req.on(‘data’,…)
速度慢，安全性相对高，数据量大

4.路由器
路由的使用过程中，不同的模块可能出现相同的URL，把同一个模块下的所有路由放到一个容器，
这个容器就是路由器。路由器最终要引入到web服务器下才能使用。

（1）创建路由器模块(自定义模块)
const express=require(‘express’);
var router=express.Router(); //创建路由器对象
router.get(’/list’,function(req,res){ }); //添加路由
module.exports=router; //导出路由器对象

//引入express
const express=require(‘express’);
//使用express创建空的路由器
//返回对象
var router=express.Router();
//往路由器中添加路由
router.get(’/list’,function(req,res){
res.send(‘这是商品模块下的列表’);
});
//导出路由器
module.exports=router;

（2）在web服务器下使用路由器
const productRouter=require(’./product.js’);
server.use(’/product’,productRouter);
//把路由器挂载到/product下，访问形式 /product/list

const express=require(‘express’);
//引入商品路由器(自定义模块)
const productRouter=require(’./product.js’);
//创建web服务器
var server=express();
//设置端口
server.listen(8080);

//商品模块路由
//使用商品路由器
//挂载到/produce下
// /produce/list
//参数1：挂载的位置
//参数2：使用的路由器
server.use(’/product’,productRouter);

7.中间件

中间件理解是一个过滤器，作用是为主要的业务逻辑服务
分为应用级中间件，路由级中间件，内置中间件，第三方中间件，错误处理中间件

1.应用级(自定义)中间件——每个中间件都是一个函数
server.use(path,function(req.res.next){ })
path 表示中间件所要拦截的请求 URL，如果为空，表示要拦截所有的请求
next 是一个函数，用于执行下一步（可能是下一个中间件，也可能是路由）

const express=require(‘express’);
var server=express();
server.listen(8080);
//使用中间件验证注册
//参数1：给哪一个URL的路由使用；如果为空标识会给所有的路由使用
//参数2：中间件函数；获取请求，以及做出响应
server.use(’/reg’,function(req,res,next){
console.log(‘验证了数据是否为空’);
//会执行下一个中间件或者路由
next();
});
//主要的业务逻辑
server.get(’/reg’,function(req,res){
res.send(‘注册成功’);
});
server.get(’/list’,function(req,res){
res.send(‘这是商品列表’);
});

//创建路由响应当前浏览次数，每次浏览次数加1
var n=0;
//添加中间件，给/view使用
server.use(’/view’,function(req,res,next){
n++;//++ 隐式将n转成数字
next();
});
server.get(’/view’,function(req,res){
res.send(n.toString());
});

2.路由级中间件
路由器的使用server.use(path,路由器);

3.内置中间件
在express下只保留了一个内置的中间件
server.use(express.static(‘目录’));
把静态资源托管到指定的目录，如果浏览器请求静态资源，自动到该目录下查找。
静态资源：html,css,浏览器js,图像…
const express=require(‘express’);
var server=express();
server.listen(8080);

//静态资源：html,css,浏览器端js,img…
//把所有的静态资源托管到public目录
//使用内置中间件static
server.use(express.static(‘public’));

4.第三方中间件
命令行安装 npm install 中间件名称
//1.引入 body-parser
const bodyParser=require(‘body-parser’);
//2.使用中间件，可以将 post 请求数据解析为对象
server.use(bodyParser.urlencoded({
extended:false
}));
//3.在路由中获取 post 请求数据
req.body
urlencoded：将post请求的数据格式化为对象
extended：不是用第三方qs模块，而是使用核心模块querystring将查询字符串格式化为对象

const express=require(‘express’);
//引入body-parser中间件
const bodyParser=require(‘body-parser’);
//创建web服务器
var server=express();
server.listen(8080);
//托管静态资源到public目录
server.use(express.static(‘public’));
//使用body-parser中间件将post请求数据格式化为对象
server.use(bodyParser.urlencoded({
extended:false
//不使用扩展的qs模块，而是使用querystring模块格式化为对象
}));
//根据浏览器的请求写对应路由
server.post(’/login’,function(req,res){
//获取post请求的数据，格式化为对象
//前提：已经使用了中间件body-parser
console.log(req.body);
res.send(‘登录成功’);
});

8.mysql模块

1.连接mysql
1.创建连接对象：var connection=mysql.createConnection();
传递连接数据库需要的服务器，端口，用户名，密码，要使用的数据库
2.建立连接：connection.connect()
3.connection.query(sql,callback)
sql是要执行的SQL语句；callback回调函数，用于获取SQL语句
4.关闭连接：connection.end()
执行完所有的SQL语句，关闭连接

//引入mysql模块
const mysql=require(‘mysql’);
//创建连接对象
var connection=mysql.createConnection({
host:‘127.0.0.1’,
port:‘3306’,
user:‘root’,
password:’’,
database:‘tedu’//连接后使用的数据库
})
//建立连接
connection.connect();
connection.query(‘SELECT * FROM emp’,function(err,result){
//err可能产生的错误
if(err) throw err;
//result执行的结果
console.log(result);
});
//关闭连接
connection.end();

2.连接池
1.创建连接池对象：var pool=mysql.createPool();
传递连接需要的服务器地址，端口，用户名，密码，要使用数据库，设置连接池的大小
connectionLimit，默认是15
2.pool.query(sql,callback)
执行SQL语句，sql要执行的SQL语句；callback回调函数，用于获取结果

//引入mysql
const mysql=require(‘mysql’);
//创建连接池对象，自动建立连接
var pool=mysql.createPool({
host:‘127.0.0.1’,
port:‘3306’,
user:‘root’,
password:’’,
database:‘tedu’,
connectionLimit:20 //设置连接池的大小
});
//执行SQL语句
pool.query(‘SELECT * FROM emp’,function(err,result){
if(err) throw err;
console.log(result);
})

3.sql注入，使用占位符(?)，对用户提供的数据进行过滤
pool.query(‘UPDATE dept SET dname=? WHERE DID=?’,[‘测试1部’，40],function(err,result){
if(err) throw err;
console.log(result);
});