Node

Adrian Yang

Adrian Yang

Front End Engineer

Node.js

基于ChromeV8 引擎的 Javascript 运行时

image-20200714203552836

NodeJS 优点

  1. 异步非阻塞的I/O(I/O线程池)
  2. 特别适用于I/O密集型应用
  3. 事件循环机制 (与浏览器不一样)
  4. 单线程 (成也单线程,败也单线程,对比java服务器)
  5. 跨平台

单线程如果想实现"异步",就要有自己的事件循环机制

不足之处

  1. 回调函数过多 产生回调地狱
  2. 单线程 处理不好CPU 密集型任务

跨平台如何实现

  1. js 引擎 -> 谷歌等
  2. java -> JVM 虚拟机 ->
  3. Node.js

CPU 密集型

一些进程绝大多数时间在计算上,称为计算密集型(CPU密集型)computer-bound。一些大量循环的代码(例如:图片处理、视频编码)就是CPU密集型

IO密集型

有一些进程则在input 和output上花费了大多时间,称为I/O密集型,I/O-bound。比如搜索引擎蜘蛛大多时间是在等待相应这种就属于I/O密集型。

Lektion 1 Node 简介

Node 中函数的特点

1.Node中任何一个模块(js文件)都被一个外层函数所包裹

  • function (exports, require, module, filename, dirname) {}

  • exports:用于支持CommonJs模块化规范的暴露语法

  • require:用于支持CommonJs模块化规范的引入语法

  • module:用于支持CommonJs模块化规范的暴露语法

  • __filename:当前运行文件的绝对路径

  • __dirname:当前运行文件所在文件夹的绝对路径

2.为什么要设计这个外层函数(这个外层函数有什么作用?)

  • 1).用于支持模块化语法

  • 2).隐藏服务器内部实现(从作用域角度去看)

外层函数,外层函数到底接收了什么参数? console.log(arguments.callee.toString()) //输出外层函数

Node 中 Global

1.浏览器端,js由哪几部分组成?

  • 1.BOM ----> window 浏览器对象模型 -------- 很多的API(location,history)
  • 2.DOM ----> document 文档对象模型 ---------- 很多的API(对DOM的增删改查)
  • 3.ES规范 -------------------- ES5、ES6.....

2.Node端,js由几部分组成?

  • 1.没有了BOM -----> 因为服务器不需要(服务端没有浏览器对象)
  • 2.没有了DOM -----> 因为没有浏览器窗口
  • 3.几乎包含了所有的ES规范
  • 4.没有了window,但是取而代之的是一个叫做global的全局变量。

3.global的一些常用属性

clearImmediate:清空立即执行函数 clearInterval:清除循环定时器 clearTimeout: 清除延迟定时器

setImmediate:设置立即执行函数 setInterval:设置循环定时器 setTimeout: 设置延迟定时器

在Node中禁止函数的this指向global,而是指向了一个空对象 { }

Node_EventLoop

┌───────────────────────────┐
┌─>│ timers │定时器阶段: 开始计时 执行定时器回调
│ └─────────────┬─────────────┘
│ ┌─────────────┴─────────────┐
│ │ pending callbacks │系统阶段
│ └─────────────┬─────────────┘
│ ┌─────────────┴─────────────┐
│ │ idle, prepare │准备阶段
│ └─────────────┬─────────────┘ ┌───────────────┐
│ ┌─────────────┴─────────────┐ │ incoming: │
│ │ poll │<─────┤ connections, │ 轮询阶段
│ └─────────────┬─────────────┘ │ data, etc. │
│ ┌─────────────┴─────────────┐ └───────────────┘
│ │ check │ 专门用于执行setImmediate所设置的回调
│ └─────────────┬─────────────┘
│ ┌─────────────┴─────────────┐
└──┤ close callbacks │关闭闭回调阶段
└───────────────────────────┘
process.nextTick() //设置立即执行函数 ----能在任意阶段优先执行

Poll 轮询阶段 !important

---如果回调队列里有待执行的回调函数
从回调队列中取出回调函数,同步执行(一个一个执行),直到回调队列为空了,或者达到系统最大限度。
---如果回调队列为空
---如果有设置过setImmediate
进入下一个check阶段,目的:为了执行setImmediate所设置的回调。
---如果未设置过setImmediate
在此阶段停留,等待回调函数被插入回调队列。
若定时器到点了,进入下一个check阶段,
原因:为了走第五阶段,随后走第六阶段,随后第一阶段(最终目的)

包 与 npm 管理器

如何让一个普通文件夹变成一个包? 让这个文件夹拥有一个:package.json文件即可,且package.json里面的内容要合法。 执行命令:npm init 包名的要求: 不能有大写字母、同时尽量不要以数字开头、不能与npm仓库上其他包同名。

npm的常用命令?

一、【搜索】:
1.npm search xxxxx (不推荐)
2.通过网址搜索:www.npmjs.com
二、【安装】:(安装之前必须保证文件夹内有package.json,且里面的内容格式合法)
1.npm install xxxxx --save 或 npm i xxxx -S 或 npm i xxxx
备注:
(1).局部安装完的第三方包,放在当前目录中node_modules这个文件夹里
(2).安装完毕会自动产生一个package-lock.json(npm版本在5以后才有),里面缓存的是每个下载过的包的地址,目的是下次安装时速度快一些。
(3).当安装完一个包,该包的名字会自动写入到package.json中的【dependencies(生产依赖)】里。npm5及之前版本要加上--save后缀才可以。
2.npm install xxxxx --save-dev 或 npm i xxxxx -D 安装包并将该包写入到【devDependencies(开发依赖中)】
备注:什么是生产依赖与开发依赖?
1.只在开发时(写代码时)时才用到的库,就是开发依赖-例如:语法检查、压缩代码、扩展css前缀的包。
2.在生产环境中(项目上线)不可缺少的,就是生产依赖 ------ 例如:jquery、bootStrap等等。
3.注意:某些包即属于开发依赖,又属于生产依赖 -------例如:jquery。
3.npm i xxxx -g 全局安装xxxx包(一般来说,带有指令集的包要进行全局安装,例如:browserify、babel等)
全局安装的包,其 [指令] 到处可用,如果该包不带有指令,就无需全局安装。
查看全局安装的位置:npm root -g
4.npm i xxx@yyy :安装xxx包的yyy版本
5.npm i :安装package.json中声明的所有包
三、【移除】:
npm remove xxxxx 在node_module中删除xxxx包,同时会删除该包在package.json中的声明
四、【其他命令】:
1.npm aduit fix :检测项目依赖中的一些问题,并且尝试着修复。
2.npm view xxxxx versions :查看远程npm仓库中xxxx包的所有版本信息
3.npm view xxxxx version :查看npm仓库中xxxx包的最新版本
4.npm ls xxxx :查看我们所安装的xxxx包的版本
五、【关于版本号的说明】:
"^3.x.x" :锁定大版本,以后安装包的时候,保证包是3.x.x版本,x默认取最新的。
"~3.1.x" :锁定小版本,以后安装包的时候,保证包是3.1.x版本,x默认取最新的。
"3.1.1" :锁定完整版本,以后安装包的时候,保证包必须是3.1.1版本。

替换npm仓库地址为淘宝镜像地址 命令:npm config set registry https://registry.npm.taobao.org, 查看是否更改成功:npm config get registry ,以后安装时,依然用npm命令,但是实际是从淘宝国内服务器下载的

yarn的简介与使用

Yarn发布于2016年10月,截至当前2019年1月,gitHub上的Start数量为:34.3k,已经超过npm很多了, yarn使用本地缓存,有时甚至无需互联网连接就能安装本地已经缓存过的依赖项,安装方法:npm install -g yarn

特别注意!

由于yarn的全局安装位置与npm不同,所以要配置yarn的全局安装路径到环境变量中,否则全局安装的包不起作用。 具体操作如下:

安装yarn后分别执行 yarn global dir命令,yarn global bin命令。 将上述两步返回的路径配置到电脑环境变量中即可。

yarn命令与npm命令的对应关系如下:

初始化项目:

yarn init -y
npm init -y

下载项目的所有声明的依赖:

yarn
npm install

下载指定的运行时依赖包:

yarn add xxxx@3.2.1
npm install xxxxx@3.2.1 -S

下载指定的开发时依赖:

yarn add xxxxx@3.2.1 -D
npm install xxxxx@3.2.1 -D

全局下载指定包:

yarn global add xxxxxx
npm install xxxxxxx -g

删除依赖包:

yarn remove xxxxx
yarn global remove xxxxxx
npm remove xxxxxxx -g

查看某个包的信息:

yarn info xxx
npm info xxx

设置淘宝镜像:

yarn config set registry https://registry.npm.taobao.org
npm config set registry https://registry.npm.taobao.org

Lektion 2 Buffer 缓冲器

Buffer

Buffer是什么?

  • 1.它是一个【类似于数组】的对象,用于存储数据(存储的是二进制数据)。
  • 2.Buffer的效率很高,存储和读取很快,它是直接对计算机的内存进行操作。
  • 3.Buffer的大小一旦确定了,不可修改。
  • 4.每个元素占用内存的大小为1字节。8位(bit) = 1字节(Byte)
  • 5.Buffer是Node中的非常核心的模块,无需下载、无需引入,直接即可使用

创建一个Buffer的实例对象--------性能特别差-- 为什么?---1.在堆里开辟空间 + 2.清理

let buf = new Buffer(10)
console.log(buf)

创建一个Buffer的实例对象--------性能比new Buffer()稍强一点------在堆中开辟一块空间(该块空间没有人用过)

let buf2 = Buffer.alloc(10)
console.log(buf2)

创建一个Buffer的实例对象-------性能最好的-------在堆里开辟空间

let buf3 = Buffer.allocUnsafe(10)
console.log(buf3)
  • 1.输出的Buffer为什么不是二进制? ----- 输出的是16进制,但是存储的是二进制码,输出的时候会自动转16进制。
  • 2.输出的Buffer不为空? ----- 在堆里开辟空间,可能残留着别人用过的数据,所以allocUnsafe

将数据存入一个Buffer实例

let buf4 = Buffer.from('hello')
console.log(buf4)
  • 1.输出的为什么不是我们曾经存入的字符串?:用户存储的不一定是字符串,可能是媒体类型的文件
  • 2.如何能够让输出的东西是字符串(我们能看懂的)? -> toString()

Node中的文件系统

  • 1.在NodeJs中有一个文件系统,所谓的文件系统,就是对计算机中的文件进行增删改查等操作。

  • 2.在NodeJs中,给我们提供了一个模块,叫做fs模块(文件系统),专门用于操作文件。

  • 3.fs模块是Node的核心模块,使用的时候,无需下载,直接引入。

### 异步文件写入 (简单文件写入)

fs.writeFile(file, data[, options], callback)

  • --file:要写入的文件路径+文件名+后缀

  • --data:要写入的数据

  • --options:配置对象(可选参数)

    • --encoding:设置文件的编码方式,默认值:utf8(万国码)
    • --mode:设置文件的操作权限,默认值是:0o666 = 0o222 + 0o444
      * --0o111:文件可被执行的权限 .exe .msc 几乎不用,linux有自己一套操作方法。
      * --0o222:文件可被写入的权限
      * --0o444:文件可别读取的权限
  • --flag:打开文件要执行的操作,默认值是'w'

    • --a :追加
    • --w :写入
  • --callback:回调函数

    • --err:错误对象
  • 在Node中有这样一个原则:错误优先
//引入内置的fs模块
let fs = require('fs')
//调用writeFile方法`
fs.writeFile(__dirname+'/demo.txt','kobe,123',{mode:0o666,flag:'w'},err => {
if(err) console.log('文件写入失败',err)
else console.log('文件写入成功')
})

流式文件写入

创建一个可写流

fs.createWriteStream(path[, options])

  • --path:要写入文件的路径+文件名+文件后缀
  • --options:配置对象(可选参数)
    • --flags:
    • --encoding :
    • --fd : 文件统一标识符,linux下文件标识符
    • --mode :
    • --autoClose : 自动关闭 --- 文件,默认值:true
    • --emitClose : 关闭 --- 文件,默认值:false
    • --start : 写入文件的起始位置(偏移量)
let fs = require('fs')
//创建一个可写流----水管到位了
let ws = fs.createWriteStream(__dirname+'/demo.txt',{start:10})
.23w5edtg46r5h6u7j8i9k0o[867yhbnjmk,olp;'[\]
[':?;'[-'p;/.']]'/
ws.on('open',function () {
console.log('可写流打开了')
})
ws.on('close',function () {
console.log('可写流关闭了')
})
//使用可写流写入数据
ws.write('美女\n')
ws.write('霉女?\n')
ws.write('到底是哪一个?\n')
//ws.close() //如果在Node的8版本中,使用此方法关闭流会造成数据丢失
ws.end() //在Node的8版本中,要用end方法关闭流

简单文件读取:

fs.readFile(path[, options], callback)

  • --path:要读取文件的路径+文件名+后缀
  • --options:配置对象(可选)
  • --callback:回调
    * --err:错误对象
    * --data:读取出来的数据

简单文件写入和简单文件读取,都是一次性把所有要读取或要写入的内容加到内存中,容易造成内存泄露。`

let fs = require('fs')
fs.readFile(__dirname+'/test.mp4',function (err,data) {
if(err) console.log(err)
//为什么读取出来的东西是Buffer? :用户存储的不一定是纯文本
else console.log(data)
fs.writeFile('../test.mp4',data.function(err){
if(err) console.log(err)
else console.log('sucess!')
})
})

流式文件读取:

fs.createReadStream(path[, options])

  • --start :起始偏移量
  • --end : 结束偏移量
  • --highWaterMark:每次读取数据的大小,默认值是64 * 1024
let {createReadStream,createWriteStream} = require('fs')
//创建一个可读流
let rs = createReadStream(__dirname+'/music.mp3',{
highWaterMark:10 * 1024 * 1024,
//start:60000,
//end:120000
})
//创建一个可写流
let ws = createWriteStream('../haha.mp3')
//只要用到了流,就必须监测流的状态
rs.on('open',function () {
console.log('可读流打开了')
})
rs.on('close',function () {
console.log('可读流关闭了')
ws.close() !
})
ws.on('open',function () {
console.log('可写流打开了')
})
ws.on('close',function () {
console.log('可写流关闭了')
})
//给可读流绑定一个data事件,就会触发可读流自动读取内容。
rs.on('data',function (data) {
//Buffer实例的length属性,是表示该Buffer实例占用内存空间的大小
console.log(data.length) //输出的是65536,每次读取64KB的内容 (size)
ws.write(data)
//ws.close() //若在此处关闭流,会写入一次,后续数据丢失
})
//ws.close() //若在此处关闭流,导致无法写入数据
//小文件可以直接用简单文件的读写,大文件最好用流式的文件读写

Node 服务器的搭建

Node 原生服务器

不借助任何第三方库,去搭建Node原生服务器

//1.引入Node内置的http模块
let http = require('http')
//引入一个内置模块,用于解析[key=value&key=value...]这种形式的字符串为js中的对象
let qs = require('querystring')
/*
备注:
1.key=value&key=value.....的编码形式:urlencoded编码形式。
2.请求地址里携带urlencoded编码形式的参数,叫做:查询字符串参数(query参数)。
引入的qs是一个对象,该对象身上有着很多有用的方法,最具代表性的:parse()
**/
//2.创造一个“服务员” ---- 创建服务对象
let server = http.createServer(function (request,response) {
//让服务员开始干活,获取客人点的菜单
/*
* (1).request:请求对象,里面包含着客户端给服务器的“东西”
* (2).response:响应对象,里面包含着服务器要返回给客户端的“东西”
* */
//获取客户端携带过来的urlencoded编码形式的参数
let params = request.url.split('?')[1] //name=zhangsan&age=18
//console.log(params)
let objParams = qs.parse(params) //
//console.log(objParams)
let {name,age} = objParams
response.setHeader('content-type','text/html;charset=utf-8')
response.end(`<h1>你好${name},你的年龄是${age}</h1>`)
})
//3.指定服务器运行的端口号(绑定端口监听)
server.listen(3000,function (err) {
if (!err) console.log('服务器启动成功了')
else console.log(err)
})

GET请求与POST请求

前言

HTTP设定了八种发送请求方式(也称为八大“动作”)。这八种方法没有任何本质上的区别。只是让请求,更加有语义化而已。 八种方法分别为:OPTIONS、HEAD、GET、POST、PUT、DELETE、TRACE、CONNECT 这八种方法最终经过“岁月沉淀”后,最常用的是这两种:GET、POST

GET

1. 含义:从指定的资源获取数据(一种“索取”的感觉)。
2. 什么时候使用GET请求较为合适?
(1)单纯获取数据的时。
(2)请求非敏感数据时。

POST

1.含义:向指定的资源提交要被处理的数据(一种“交差”的感觉)。
2.什么时候使用POST请求较为合适?
(1)传送相对敏感数据时。
(2)请求的结果有持续性的副作用,例如:传递的数据要写入数据库时。
备注:使用了POST不代表的绝对的安全。

常见的GET请求:

1.浏览器地址栏输入网址时(即浏览器请求页面时,且无法手动更改)。
2.可以请求外部资源的html标签,例如:<img> <a> <link> <script>,且无法手动更改。
3.发送Ajax时若没有指定发送请求的方式,则使用GET方式,或者明确指出了使用GET请求。
4.form表单提交时,若没有指明方式,默认使用GET。

常见的POST请求:

1.发送Ajax时,明确指出了使用POST方式时。
2.form表单提交时明确指出使用POST方式

Express

Express 是一个基于 Node.js 平台的极简、灵活的 web 应用开发框架,它提供一系列强大的特性,帮助你快速创建各种 Web 和移动设备应用。

简单来说Express就是运行在node中的用来搭建服务器的模块

//引入express
const express = require('express')
//1.创建app服务对象
const app = express()
//禁止服务器返回X-Powered-By
app.disable('x-powered-by')
//2.配置路由 ------ 对请求的url进行分类,服务器根据分类决定交给谁去处理。
/*
(1).在Node.js中,我们所有说的“路由”,默认都是指【后端路由】
(2).路由可以理解为:一组一组key-value的组合,key:请求方式 + URI路径 , value:回调函数
(3).根据路由定义的顺序(写代码的顺序),依次定义好路由,随后放入一个类似数组的结构,当有请求时,依次取出匹配。若匹配成功,不再继续匹配了。
(4).该URL:http://locahost:3000/meishi 中meishi,叫什么? 1.URI名字 2.虚拟路径名字
*/
//根路由
app.get('/',function (request,response) {
/*
* 问题:得是什么样的请求,能交给这个回调函数处理?
* 1.请求方式必须为GET
* 2.请求的URI必须为:“/”
* */
console.log(request.query)
console.log(request.url)
response.send('ok')
})
//一级路由
app.get('/meishi',function (request,response) {
/*
* 问题:得是什么样的请求,能交给这个回调函数处理?
* 1.请求方式必须为GET
* 2.请求的URI必须为:“/meishi”
* */
response.send('<h1>我是美食页面</h1>')
})
//二级路由
app.get('/meishi/c17',function (request,response) {
response.send('我是美食-火锅页面')
})
//根路由
app.post('/',function (request,response) {
response.send('你发的是post请求')
})
//3.指定服务器运行的端口号(绑定端口监听)
app.listen(3000,function (err) {
if (!err) console.log('服务器启动成功了')
else console.log(err)
})

路由

路由是指如何定义应用的端点(URIs)以及如何响应客户端的请求。

路由是由一个 URI、HTTP 请求(GET、POST等)和若干个句柄组成的。

我们可以将路由定义为三个部分:

  1. 第一部分:HTTP请求的方法(get或post)

  2. 第二部分:URI路径

  3. 第三部分: 回调函数

Express中提供了一系列函数,可以让我们很方便的实现路由:

request和response都有什么API?

1.request对象: request.query 获取查询字符串参数(query参数),拿到的是一个对象 request.params 获取get请求参数路由的参数,拿到的是一个对象 request.body 获取post请求体参数,拿到的是一个对象(不可以直接用,要借助一个中间件) request.get(xxxx) 获取请求头中指定key对应的value。

2.response对象: response.send() 给浏览器做出一个响应 response.end() 给浏览器做出一个响应(不会自动追加响应头) response.download() 告诉浏览器下载一个文件,可以传递相对路径 response.sendFile() 给浏览器发送一个文件 备注:必须传递绝对路径 __dirname response.redirect() 重定向到一个新的地址(url) response.set(key,value) 自定义响应头内容 response.get(key) 获取响应头指定key对应的value 很少使用 response.status(code) 设置响应状态码

let express = require('express')
let app = express()
//根路由
app.get('/',function (request,response) {
//.log(request.query)
//console.log(request.get('Host'))
//console.log(request.get('Referer'))
response.send('250') //send方法里不能传入纯数字,express会当成状态码
})
//根路由
app.post('/',function (request,response) {
console.log(request.body)
response.send('我是根路由返回的数据--post')
})
//一级路由
app.get('/demo',function (request,response) {
/*
* 什么叫做服务器给浏览器响应了?
* 1.服务器给浏览器一段文字
* 2.服务器给了浏览器一个图片
* 3.服务器给了浏览器一个视频
* 4.服务器告诉浏览器下载一个文件
* 5.服务器告诉浏览器重定向
* 备注:多个响应以response.send为主
* */
//response.download('./public/vue.png')
//response.sendFile(__dirname+'/public/demo.zip')
//response.redirect('https://www.baidu.com')
//response.redirect('/demo/test')
//response.set('demo','0719')
//response.status(200)
response.send('我是demo路由返回的数据')
//console.log(response.get('demo'));
//response.send('等等我还有点东西') //会抛一个异常,不能send两次
})
//二级路由
app.get('/demo/test',function (request,response) {
response.send('我是demo/test路由返回的数据')
})
//参数路由---可以动态接收参数
app.get('/meishi/:id',function (request,response) {
console.log(request.params);
let {id} = request.params
response.send(`我是变化为${id}的商家`)
})
app.listen(3000,function (err) {
if(!err) console.log('ok')
else console.log(err)
})

中间件 middleWare

中间件: 概念:本质上就是一个函数,包含三个参数:request、response、next

作用: 1) 执行任何代码。 2) 修改请求对象、响应对象。 3) 终结请求-响应循环。(让一次请求得到响应) 4) 调用堆栈中的下一个中间件或路由。 分类: 1) 应用(全局)级中间件(过滤非法的请求,例如防盗链) --第一种写法:app.use((request,response,next)=>{}) --第二种写法:使用函数定义 2) 第三方中间件,即:不是Node内置的,也不是express内置的(通过npm下载的中间件,例如body-parser) --app.use(bodyParser.urlencoded({extended:true})) 3) 内置中间件(express内部封装好的中间件) --app.use(express.urlencoded({extended:true})) --app.use(express.static('public')) //暴露静态资源 4) 路由器中间件 (Router) --后面讲 备注: 1. 在express中,定义路由和中间件的时候,根据定义的顺序(代码的顺序),将定义的每一个中间件或路由, 放在一个类似于数组的容器中,当请求过来的时候,依次从容器中取出中间件和路由,进行匹配,如果匹配 成功,交由该路由或中间件处理,如果全局中间件写在了最开始的位置,那么他就是请求的“第一扇门”。 2. 对于服务器来说,一次请求,只有一个请求对象,和一个响应对象,其他任何的request和response都是对二者的引用。

const express = require('express')
//引入body-parser,用于解析post参数
//const bodyParser = require('body-parser')
const app = express()
//【第一种】使用应用级(全局)中间件------所有请求的第一扇门-------所有请求都要经过某些处理的时候用此种写法
app.use((request,response,next)=>{
//response.send('我是中间件给你的响应')
//response.test = 1 //修改请求对象
//图片防盗链
if(request.get('Referer')){
let miniReferer = request.get('Referer').split('/')[2]
if(miniReferer === 'localhost:63347'){
next()
}else{
//发生了盗链
response.sendFile(__dirname+'/public/err.png')
}
}else{
next()
}
//next()
})
//【第二种】使用全局中间件的方式------更加灵活,不是第一扇门,可以在任何需要的地方使用。
function guardPic(request,response,next) {
//防盗链
if(request.get('Referer')){
let miniReferer = request.get('Referer').split('/')[2]
if(miniReferer === 'localhost:63347'){
next()
}else{
//发生了盗链
response.sendFile(__dirname+'/public/err.png')
}
}else{
next()
}
}
//使用第三方中间件bodyParser
//解析post请求请求体中所携带的urlencoded编码形式的参数为一个对象,随后挂载到request对象上
//app.use(bodyParser.urlencoded({extended: true}))
//解析post请求请求体中所携带的urlencoded编码形式的参数为一个对象,随后挂载到request对象上
app.use(express.urlencoded({extended: true}))
//使用内置中间件去暴露静态资源 ---- 一次性把你所指定的文件夹内的资源全部交出去。
app.use(express.static(__dirname+'/public'))
app.get('/',(request,response)=>{
console.log(request.demo)
response.send('ok')
})
app.get('/demo',(request,response)=>{
console.log(request.demo)
console.log(request.query)
response.send('ok2')
})
app.get('/picture',guardPic,(request,response)=>{
response.sendFile(__dirname+'/public/demo.jpg')
})
app.post('/test',(request,response)=>{
console.log(request.body)
response.send('ok')
})
app.listen(3000,function (err) {
if(!err) console.log('ok')
else console.log(err)
})

路由器

Router 是一个完整的中间件和路由系统,也可以看做是一个小型的app对象。

为了更好的分类管理route

//引入UI路由器
const UIRouter = require('./router/UIRouter')
//引入登录注册路由器
const loginRegisterRouter = require('./router/loginRegisterRouter')
db(()=>{
//使用UIRouter
app.use(UIRouter())
//使用loginRegisterRouter
app.use(loginRegisterRouter())
======
UI router
//引入Router构造函数
const {Router} = require('express')
//创建一个Router实例(路由器就是一个小型的app)
let router = new Router()
//引入path模块----Node中内置的一个专门用于解决路径问题的库
let {resolve} = require('path')
//用于展示登录界面的路由,无其他任何逻辑 ----- UI路由
router.get('/login',(req,res)=>{
let url = resolve(__dirname,'../public/login.html')
res.sendFile(url)
})
//用于展示注册界面的路由,无其他任何逻辑 ----- UI路由
router.get('/register',(req,res)=>{
let url = resolve(__dirname,'../public/register.html')
res.sendFile(url)
})
module.exports = function () {
return router
}

数据库

关系型数据库

代表有:MySQL、Oracle、DB2、SQL Server...

特点:关系紧密,都是表

优点:

  1. 易于维护:都是使用表结构,格式一致;

  2. 使用方便:SQL语言通用,可用于复杂查询;

  3. 高级查询:可用于一个表以及多个表之间非常复杂的查询。

缺点:

  1. 读写性能比较差,尤其是海量数据的高效率读写;

  2. 有固定的表结构,字段不可随意更改,灵活度稍欠;

  3. 高并发读写需求,传统关系型数据库来说,硬盘I/O是一个很大的瓶颈。

非关系型数据库 NoSQL

代表有:MongoDB、Redis...

特点:关系不紧密,有文档,有键值对

优点:

1、格式灵活:存储数据的格式可以是key,value形式。

2、速度快:nosql可以内存作为载体,而关系型数据库只能使用硬盘;

3、易用:nosql数据库部署简单。

缺点:

1、不支持sql,学习和使用成本较高;

2、不支持事务;[原子性, 不可分割性]

3、复杂查询时语句过于繁琐。

关系型数据库非关系型数据库
Excel文件数据库数据库
sheet页签表集合
列头字段字段
一行一条数据一条文档

MongoDB基本命令

  1. db : 查看当前在操作哪一个数据库

  2. show dbs :查看数据库列表(一共有几个数据库,备注:如果数据库为空,不出现在列表中)

  3. use test :切换到test数据库,如果不存在,则创建一个test库

  4. db.students.insert() :向当前数据库的students集合中插入一个文档。

  5. show collections :展示当前数据库中所有的集合。

MongoDB原生CRUD(增删改查)命令总结

-C creat(新增数据):

db.集合名.insert(文档对象)
db.集合名.insertOne(文档对象)
db.集合名.insertMany([文档对象,文档对象])

-R read:

db.集合名.find(查询条件[,投影])
举例:db.students.find({age:18}),查找年龄为18的所有信息
举例:db.students.find({age:18,name:'jack'}),查找年龄为18且名字为jack的学生
常用操作符:
1. < , <= , > , >= , !== 对应为: $lt $lte $gt $gte $ne
举例:db.集合名.find({age:{$gte:20}}),年龄是大于等于20的
2.逻辑或:使用$in 或 $or
查找年龄为18或20的学生
举例:db.students.find({age:{$in:[18,20]}})
举例:db.students.find({$or:[{age:18},{age:20}]})
3.逻辑非:$nin
4.正则匹配:
举例:db.students.find({name:/^T/})
5.$where能写函数:
db.students.find({$where:function(){
return this.name === 'zhangsan' && this.age === 18
}})
投影:过滤掉不想要的数据,只保留想要展示的数据
举例:db.students.find({},{_id:0,name:0}),过滤掉id和name
举例:db.students.find({},{age:1}),只保留age
补充:db.集合名.findOne(查询条件[,投影]),默认只要找到一个

-U update:

db.集合名.update(查询条件,要更新的内容[,配置对象])
//如下写法会将更新内容替换掉整个文档对象,但_id不受影响
举例:db.students.update({name:'zhangsan'},{age:19})
//使用$set修改指定内容,其他数据不变,不过只能匹配一个zhangsan
举例:db.students.update({name:'zhangsan'},{$set:{age:19}})
//修改多个文档对象,匹配多个zhangsan,把所有zhangsan的年龄都替换为19
举例:db.students.update({name:'zhangsan'},{$set:{age:19}},{multi:true})
补充:db.集合名.updateOne(查询条件,要更新的内容[,配置对象])
db.集合名.updateMany(查询条件,要更新的内容[,配置对象])

-D delete

db.集合名.remove(查询条件)
//删除所有年龄小于等于19的学生
举例:db.students.remove({age:{$lte:19}})

Mogoose CRUD

模式 对象 -> 模型对象

-Create

模型对象.create(文档对象,回调函数)

-Read

模型对象.find(查询条件[,投影],回调函数)不管有没有数据,都返回一个数组
模型对象.findOne(查询条件[,投影],回调函数)找到了返回一个对象,没找到返回null

-Update

模型对象.updateOne(查询条件,要更新的内容[,配置对象],回调函数)
模型对象.updateMany(查询条件,要更新的内容[,配置对象],回调函数)
备注:存在update方法,但是即将废弃,查询条件匹配到多个时,依然只修改一个,强烈建议用updateOne或updateMany

-Delete

模型对象.deleteOne(查询条件,回调函数)
模型对象.deleteMany(查询条件,回调函数)
备注:没有delete方法,会报错!

备注: 以上所有方法,如果没有指定回调函数,则返回值是一个Promise的实例

Mongoose

Mongoose是一个对象文档模型(ODM)库,它对Node原生的MongoDB模块进行了进一步的优化封装,并提供了更多的功能。

优势

1) 可以为文档创建一个模式结构(Schema)

2) 可以对模型中的对象/文档进行验证

3) 数据可以通过类型转换转换为对象模型

4) 可以使用中间件来应用业务逻辑挂钩

5) 比Node原生的MongoDB驱动更容易

  • mongoDB:一个数据库品牌的名字

  • mongod:启动数据库的命令

  • mongo:连接接数据库的命令

  • mongoose:在Node平台下,一个知名的用于帮助开发者连接mongoDB的包

为什么用mongoose? :想在Node平台下,更加简单、高效、安全、稳定的操作mongoDB

当引入第三方库的时候,如果在本文件夹内没有找到node_modules,找外层文件夹,直到根目录

//引入mongoose
let mongoose = require('mongoose')
//1.连接数据库
mongoose.connect('mongodb://localhost:27017/demo',{
useNewUrlParser: true, //使用一个新的URL解析器,用于解决一些安全性问题。
useUnifiedTopology: true //使用一个统一的新的拓扑结构
})
//2.绑定数据库连接的监听
mongoose.connection.on('open',function (err) {
if(err){
console.log('数据库连接失败',err)
}else{
console.log('数据库连接成功')
//3.操作数据库
//把数据库想象成你家的别墅
//1.请来一个帮你看门的保安 ------ 引入模式对象
let Schema = mongoose.Schema
//2.制定进入你家的规则 -------- 创建约束对象
let studentsRule = new Schema({
stu_id:{
type:String, //限制学号必须为:字符串
required:true,
unique:true
},
name:{
type:String, //限制姓名必须为:字符串
required:true, //限制姓名为必填项
},
age:{
type:Number, //限制年龄必须为:字符串
required:true, //限制年龄为必填项
},
sex:{
type:String, //限制性别必须为:字符串
required:true, //限制性别为必填项
},
hobby:[String], //限制爱好只能为数组,数组中的每一项必须为字符串
info:Schema.Types.Mixed, //接收所有类型
date:{
type:Date,
default:Date.now()
},
enable_flag:{ // 标识数据是否有效
type:String,
default:'Y'
}
})
//3.告诉保安你的规则 ------- 创建模型对象
let stuModel = mongoose.model('students',studentsRule) //用于生成某个集合所对应的模型对象
//4.真正有人要进入你家了 -------- CRUD
//新增操作 --- C
stuModel.create({
stu_id:'888',
name:'强',
age:'42',
sex:'男',
hobby:['女','打代码','打篮球'], //限制爱好只能为数组,数组中的每一项必须为字符串
info:'一个风一样的男子', //接收所有类型
},function(err,data){
if (!err) console.log(data)
else console.log(err)
})
//查询 --- R
/*find方法:
1.返回的是一个数组,就算是一条数据,也包裹一个数组
2.若查询结果为空,则返回一个空数组 []
*/
stuModel.find({name:'金龙老师'},function (err,data) {
if (!err) console.log(data)
else console.log(err)
})
/*findOne方法:
1.若有结果,返回的是一个对象
2.若没有结果,返回一个null
*/
stuModel.findOne({name:'班长'},{age:1,_id:0},function (err,data) {
if (!err) console.log(data)
else console.log(err)
})
//更新 --- U
stuModel.updateOne({name:'静静'},{age:16},function (err,data) {
if (!err) console.log(data)
else console.log(err)
})
//删除 --- D
stuModel.deleteMany({age:16},function (err,data) {
if (!err) console.log(data)
else console.log(err)
})
}
})