Node
Adrian Yang
Front End EngineerNode.js
基于ChromeV8 引擎的 Javascript 运行时

NodeJS 优点
- 异步非阻塞的I/O(I/O线程池)
- 特别适用于I/O密集型应用
- 事件循环机制 (与浏览器不一样)
- 单线程 (成也单线程,败也单线程,对比java服务器)
- 跨平台
单线程如果想实现"异步",就要有自己的事件循环机制
不足之处
- 回调函数过多 产生回调地狱
- 单线程 处理不好CPU 密集型任务
跨平台如何实现
- js 引擎 -> 谷歌等
- java -> JVM 虚拟机 ->
- 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 -ynpm init -y下载项目的所有声明的依赖:
yarnnpm install下载指定的运行时依赖包:
yarn add xxxx@3.2.1npm install xxxxx@3.2.1 -S下载指定的开发时依赖:
yarn add xxxxx@3.2.1 -Dnpm install xxxxx@3.2.1 -D全局下载指定包:
yarn global add xxxxxxnpm install xxxxxxx -g删除依赖包:
yarn remove xxxxxyarn global remove xxxxxxnpm remove xxxxxxx -g查看某个包的信息:
yarn info xxxnpm info xxx设置淘宝镜像:
yarn config set registry https://registry.npm.taobao.orgnpm config set registry https://registry.npm.taobao.orgLektion 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中的用来搭建服务器的模块
//引入expressconst express = require('express')
//1.创建app服务对象const app = express()//禁止服务器返回X-Powered-Byapp.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等)和若干个句柄组成的。
我们可以将路由定义为三个部分:
第一部分:HTTP请求的方法(get或post)
第二部分:URI路径
第三部分: 回调函数
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...
特点:关系紧密,都是表
优点:
易于维护:都是使用表结构,格式一致;
使用方便:SQL语言通用,可用于复杂查询;
高级查询:可用于一个表以及多个表之间非常复杂的查询。
缺点:
读写性能比较差,尤其是海量数据的高效率读写;
有固定的表结构,字段不可随意更改,灵活度稍欠;
高并发读写需求,传统关系型数据库来说,硬盘I/O是一个很大的瓶颈。
非关系型数据库 NoSQL
代表有:MongoDB、Redis...
特点:关系不紧密,有文档,有键值对
优点:
1、格式灵活:存储数据的格式可以是key,value形式。
2、速度快:nosql可以内存作为载体,而关系型数据库只能使用硬盘;
3、易用:nosql数据库部署简单。
缺点:
1、不支持sql,学习和使用成本较高;
2、不支持事务;[原子性, 不可分割性]
3、复杂查询时语句过于繁琐。
| 关系型数据库 | 非关系型数据库 | |
|---|---|---|
| Excel文件 | 数据库 | 数据库 |
| sheet页签 | 表 | 集合 |
| 列头 | 字段 | 字段 |
| 一行 | 一条数据 | 一条文档 |
MongoDB基本命令
db : 查看当前在操作哪一个数据库
show dbs :查看数据库列表(一共有几个数据库,备注:如果数据库为空,不出现在列表中)
use test :切换到test数据库,如果不存在,则创建一个test库
db.students.insert() :向当前数据库的students集合中插入一个文档。
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,找外层文件夹,直到根目录
//引入mongooselet 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) }) }})