node.js

优势

性能高，方便，入门难度低

劣势

• 服务器提供的相对较少
• 相对于其他语言，能用得上的学习资料少
• 对程序员的要求高

运行

开发注意

node.js 使用的事 ECMA 语法，不可以使用DOM BOM

前后端交互流程

大后端

	用户 
	- > 地址栏(http[s]请求) 
	- -> web服务器（收到) 
	- - > nodejs处理请求(返回静态、动态)
	- ->请求数据库服务(返回结果)
	- ->nodejs(接收)
	- ->node渲染页面
	- ->浏览器（接收页面，完成最终渲染)

大前端

	用户 
	- > http[s]请求 
	- -> web服务器（收到) 
	- - > nodejs处理请求(返回静态、动态)
	- ->请求数据库服务(返回结果)
	- ->nodejs(接收)
	- ->返回给前端(渲染)
	- ->浏览器（接收页面，完成最终渲染)

实现

引入http模块

let http = require('http')

创建web服务 返回http对象

let app = http.createServer((req,res)=>{
	req 请求体  浏览器->服务器
	req.url  地址   提取地址栏数据
	req.on('data') 提取非地址栏数据 所有的http[s]都会触发end事件
	req.on('end') 
	
	res 响应  服务器->浏览器
	res.writeHead(200,{'Content-Type':'text/html;charset=utf-8'});响应头设置
	res.write(字符/数据<string><buffer>) 返回数据
	res.end() 结束响应 必须
})

监听服务器

app.listen(端口，[地址]，[回调])

FS模块

磁盘操作，文件操作

读取

fs.readFile('文件路径',[编码方式],(err,data)=>{})

[err]： err 错误 ,null没有错误
[data]： 数据流，buffer流

变量 = fs.readFileSync('文件路径') 

处理错误

try{要排错的代码}catch(e){}

更改名字

fs.renameSync('改前','改后');

删除

fs.unlinkSync('文件路径')

静态资源托管

前端资源请求

<a href=".."></a>
<img src="..."/>

后端资源读取

fs.readFile(文件名,[编码方式],回调(err,data));

接口实现

前端

表单：get/post/put/delete/…

js： ajax/jsonp

后端

处理方式：http[s]

​ address: req.url 抓取 get请求的数据 切字符 | url模块

​ !address: req.on('data',(chunk)=>{CHUNK==每次收到的数据buffer})

​ req.on('end',()=>{ 接收完毕 切字符 querystring })

URL模块

作用

处理URL型的字符串

用法

url.parse(str,true)  返回 对象	true处理query为对象

str -> obj 返回 对象 true
protocol: ‘http:’, 协议
slashes: true, 双斜杠
auth: null, 作者
host: ‘localhost:8002’, 主机
port: ‘8002’, 端口
hostname: ‘localhost’, baidu
hash: ‘#title’, 哈希（锚)
search: ‘?username=sdfsdf&content=234234’, 查询字符串
query: ‘username=sdfsdf&content=234234’, 数据
pathname: ‘/aaa’, 文件路径
path: ‘/aaa?username=sdfsdf&content=234234’, 文件路径
href: 'http://localhost:8002/aaa?username=sdfsdf&content=234234#title’

url.format(obj) 返回字符

obj -> str 返回str

querystring模块

作用

处理查询字符串 如：?key=value&key2=value2

用法

querystring.parse(str) 返回对象

querystring.stringify(obj) 返回字符串

资源托管

//1.引入相应的原生模块、依赖
let http = require("http")
let fs = require("fs")

//2.实例化http对象（服务器对象）
let app = http.createServer((req,res)=>{
    //排除 /favicon.ico的请求
    if(req.url.indexOf("/favicon.ico") === -1){
        //需要判断要读取的是动态资源（接口api）还是静态资源
        if(req.url.indexOf("/api") !== -1){ //处理接口
            console.log("处理/api开头的动态接口",req.url)
        }else{ //处理静态资源 /index.html
            try {
                let path = req.url === "/" ? "/index.html" : req.url;
                let html = fs.readFileSync("./www"+path)
                //直接将html结果返回给浏览器
                res.write(html)    
            } catch (error) {
                let html = fs.readFileSync("./www/nopage.html")
                res.write(html)    
            }
        }
    }
    res.end() 
})

//监听服务器
app.listen(3000)

处理接口

//1.引入相应的原生模块、依赖
let http = require("http")
let fs = require("fs")
let url = require("url")
let querystring = require("querystring")

//2.实例化http对象（服务器对象）
let app = http.createServer((req,res)=>{
    //排除 /favicon.ico的请求
    if(req.url.indexOf("/favicon.ico") === -1){
        //需要判断要读取的是动态资源（接口api）还是静态资源
        if(req.url.indexOf("/api") !== -1){ //处理接口
            //处理地址栏的数据
            let urlObj = url.parse(req.url,true)
            console.log(urlObj.query)


            //非地址栏的数据
            let noAddressData = ""     //存放非地址栏的数据
            req.on("data",chunk=>{     //chunk代表抓取的一片数据，data事件内部会频繁的触发
                noAddressData += chunk
            })
            req.on("end",()=>{         //数据已经全部接受完毕
                console.log("非地址栏的数据：",querystring.parse(noAddressData))
            })
        }else{ //处理静态资源 /index.html
            try {
                let path = req.url === "/" ? "/index.html" : req.url;
                let html = fs.readFileSync("./www"+path)
                //直接将html结果返回给浏览器
                res.write(html)    
            } catch (error) {
                let html = fs.readFileSync("./www/nopage.html")
                res.write(html)    
            }
        }
    }
    res.end() 
})

//监听服务器
app.listen(3000) //3000端口号，建议不要写 1024 以及之前的防止端口冲突

模块化 commonJS

介绍

是主要为了JS在后端的表现制定，commonJS 是个规范 nodejs / webpack 是一个实现

ECMA 是个规范 js / as 实现了他

其他模块化规范：seajs.js / require.js CMD/AMD/UMD es5

作用

使变量具有文件作用域，不污染全局变量

系统模块

• http
• fs
• querystring
• url

输入

require('模块名')
require('模块名').xx 按需引用

不指定路径：先找系统模块-> 再从项目环境找node_modules|bower_components (依赖模块)->not found

指定路径 : 找指定路径 -> not found

支持任何类型

输出

exports.自定义属性 = 值 | any

批量输出 都是属性

可输出多次（以对象形式输出）

module.exports = 值 | any

只能输出一次

注意

commonJS 是 nodejs 默认模块管理方式,不支持es6的模块化管理方式，但支持所有es6+语法

NPM

作用

帮助你安装模块（包），自动安装依赖，管理包（增，删，更新，项目所有包)
类似： bower yarn

安装到全局环境

• 安装到电脑系统环境下
• 使用时在任何位置都可以使用
• 被全局安装的通常是：命令行工具，脚手架

npm i 包名 -g								安装
npm uninstall 包名 -g	 					卸载

安装到项目环境

只能在当前目录使用，需要使用npm代运行

初始化项目环境

npm init

初始化npm管理文件package.json

package-lock.json 文件用来固化依赖

{
  "name": "npm",	//项目名称
  "version": "0.0.1",	//版本
  "description": "test and play",	//描述
  "main": "index.js", //入口文件
  "dependencies": {  //项目依赖  上线也要用
    "jquery": "^3.2.1"
  },
  "devDependencies": { //开发依赖 上线就不用
    "animate.css": "^3.5.2"
  },
  "scripts": {	//命令行
    "test": "命令行",
  },
  "repository": {	//仓库信息
    "type": "git",
    "url": "git+https://github.com/alexwa9.github.io/2017-8-28.git"
  },
  "keywords": [  //关键词
    "test",'xx','oo'
  ],
  "author": "wan9",
  "license": "ISC",	//认证
  "bugs": {
    "url": "https://github.com/alexwa9.github.io/2017-8-28/issues"//问题提交
  },
  "homepage": "https://github.com/alexwa9.github.io/2017-8-28#readme"//首页
}

项目依赖

只能在当前项目下使用，上线了，也需要这个依赖 --save

//安装
npm i 包名 --save
npm install 包名 -S
npm install 包名@x.x.x -S

//卸载
npm uninstall 包名 --save
npm uninstall 包名 -S

开发依赖

只能在当前项目下使用 ，上线了，依赖不需要了 --save-dev

npm install 包名 --save-dev
npm install 包名 -D

查看包

npm list 列出所有已装包
npm outdated 版本对比(安装过得包)
npm info 包名 查看当前包概要信息
npm view 包名 versions 查看包历史版本列表

安装所有依赖

npm install
安装package.json里面指定的所有包

版本约束

^x.x.x 约束主版本，后续找最新
~x.x.x 保持前两位不变，后续找最新

•   装最新
  

x.x.x 定死了一个版本

选择源

npm install nrm -g 安装选择源的工具包
nrm ls 查看所有源
nrm test 测试所有源
nrm use 切换源名

安装卡顿时

ctrl + c -> npm uninstall 包名 -> npm cache 清除缓存 -> 换4g网络 -> npm install 包名

发布包

• 官网 注册
• 登录
  • npm login 登录
  • 输入 user/password/email
• 创建包
  • npm init -y
  • 创建入口index.js
  • 编写，输出
• 发布
  • npm publish
• 迭代
  • 修改版本号
  • npm publish
• 删除
  • npm unpublish

包的发布、迭代、删除，需要在包目录下进行

删除包，有时需要发送邮件

扩展

peerDependencies 发布依赖
optionalDependencies 可选依赖
bundledDependencies 捆绑依赖
contributors 为你的包装做出贡献的人。贡献者是一群人。
files 项目中包含的文件。您可以指定单个文件，整个目录或使用通配符来包含符合特定条件的文件

YARN

初始化一个新项目

yarn init

添加依赖包

yarn add [package]
yarn add [package]@[version]
yarn add [package]@[tag]

将依赖项添加到不同依赖项类别中

分别添加到 dependencies,devDependencies、peerDependencies 和 optionalDependencies 类别中：

yarn add [package] --save   | -S 
yarn add [package] --dev    | -D 
yarn add [package] --peer
yarn add [package] --optional

升级依赖包

yarn upgrade [package]
yarn upgrade [package]@[version]
yarn upgrade [package]@[tag]

移除依赖包

yarn remove [package]

安装项目的全部依赖

yarn
//或者
yarn install

安装到全局

yarn global add [package]				//global的位置测试不能变
yarn global remove [package]

BOWER

安装bower

npm install -g bower

安装包到全局环境

bower i 包名 -g			安装
bower uninstall 包名 -g	 卸载

初始化项目环境

bower init

bower.json 第三方包管理配置文件

项目依赖

只能在当前项目下使用，上线了，也需要这个依赖 --save

//安装
同npm
bower install 包名#x.x.x -S 指定版本使用#

//卸载
同npm

开发依赖

只能在当前项目下使用 ，上线了，依赖不需要了 --save-dev

同npm

EXPRESS

nodejs库，不用基础做起，工作简单化，点击进入官网，类似的还有 koa

特点

二次封装，非侵入式，增强型

搭建web服务

let express=require('express')
let server=express()
let server.listen(端口,地址,回调)

静态资源托管

server.use(express.static('./www'))

接口响应

支持各种请求姿势：get、post、put、delete…

server.请求姿势API(接口名称,处理函数)
server.get(url,(req,res,next)=>{})
server.post(url,(req,res,next)=>{})
...

req 请求体

request 对象表示 HTTP 请求，包含了请求查询字符串，参数，内容，HTTP 头部等属性

req.query //获取地址栏的数据
req.body //获取非地址栏的数据  依赖中间件 

req.params //获取动态接口名
req.method //获取前端提交方式

req.body依赖中间件
中间件使用:body-parser

1. npm install body-parser
2. let bodyParser = require(‘body-parser’)
3. app.use(bodyParser ())

res 响应体

response 对象表示 HTTP 响应，即在接收到请求时向客户端发送的 HTTP 响应数据

res.send(any) //对等 res.write + end
res.end(string|buffer)
res.json(json) //返回json
res.status(404).send({error:1,msg:"Sorry can't find that!"}) //返回一个404

res.jsonp(响应数据) //调用请求时的回调函数并传递响应数据
res.sendFile(path.resolve('public/error.html'))//渲染纯 HTML 文件

jsonp 响应

server.set('jsonp callback name','cb')//默认callback
server.get('/jsonp接口',(req,res,next)=>res.jsonp(数据))

处理一部分接口

共有业务逻辑,在一起给处理了

server.all('/admin/*',(req,res,next)=>{}))

all匹配全路径 处理所有HTTP
需要next 延续后续

use

安装中间件、路由、接受一个函数

server.use([地址],中间件|路由|函数体)

中间件

middleware， 处理自定义业务，只处理请求到结束响应的中间部分
例如：

npm i body-parser -S //安装包
let bodyParser=require('body-parser')//引入中间件
server.use(bodyParser())//安装中间件

body-parser 使用方式，实时查询 npm，可获得最新
自己封装一个body-parser中间件

//方式一
let querystring = require('querystring')

let bodyParser = (options) =>{
    options = options || {}
    options.limit = options.limit || 102400
    return (req,res,next) =>{
        let str = ''
        req.on('data',chunk => str += chunk)
        req.on('end',()=>{
            if(str.length > options.limit){
                throw new Error()
            }else{
                req.body = querystring.parse(str)
            }
            next()
        })
    }
}

//导出
module.exports = bodyParser

//方式二
let querystring = require('querystring')

module.exports = {
    urlencoded: (options) =>{
        options = options || {}
        options.limit = options.limit || 102400
        return (req,res,next) =>{
            let str = ''
            req.on('data', chunk => str += chunk)
            req.on('end', ()=>{
                if(str.length > options.limit){
                    throw new Error()
                }else{
                    req.body = querystring.parse(str)
                }
                next()
            })
        }
    }
}

后端跳转

res.redirect(url)      指向一个接口

扩展

req

• req.app：当callback为外部文件时，用req.app访问express的实例
• req.baseUrl：获取路由当前安装的URL路径
• req.cookies：Cookies
• req.fresh / req.stale：判断请求是否还「新鲜」
• req.hostname / req.ip：获取主机名和IP地址
• req.originalUrl：获取原始请求URL
• req.path：获取请求路径
• req.protocol：获取协议类型
• req.route：获取当前匹配的路由
• req.subdomains：获取子域名
• req.accepts()：检查可接受的请求的文档类型
• req.acceptsCharsets / req.acceptsEncodings / req.acceptsLanguages：返回指定字符集的第一个可接受字符编码
• req.get()：获取指定的HTTP请求头
• req.is()：判断请求头Content-Type的MIME类型

res

• res.app：同req.app一样
• res.append()：追加指定HTTP头
• res.set()在res.append()后将重置之前设置的头
• res.cookie(name，value [，option])：设置Cookie
• opition: domain / expires / httpOnly / maxAge / path / secure / signed
• res.clearCookie()：清除Cookie
• res.download()：传送指定路径的文件
• res.get()：返回指定的HTTP头
• res.location()：只设置响应的Location HTTP头，不设置状态码或者close response
• res.render(view,[locals],callback)：渲染一个view，同时向callback传递渲染后的字符串，如果在渲染过程中有错误发生next(err)将会被自动调用。callback将会被传入一个可能发生的错误以及渲染后的页面，这样就不会自动输出了。
• res.sendFile(path [，options] [，fn])：传送指定路径的文件 -会自动根据文件extension设定Content-Type
• res.set()：设置HTTP头，传入object可以一次设置多个头
• res.status()：设置HTTP状态码
• res.type()：设置Content-Type的MIME类型

身份验证

HTTP 是一种没有状态的协议，也就是它并不知道是谁访问。客户端用户名密码通过了身份验证，不过下回这个客户端再发送请求时候，还得再验证

session

1、客户端用户名跟密码请求登录
2、服务端收到请求，去库验证用户名与密码
3、验证成功后，服务端种一个cookie或发一个字符到客户端，同时服务器保留一份session
4、客户端收到 响应 以后可以把收到的字符存到cookie
5、客户端每次向服务端请求资源的cookie会自动携带
6、服务端收到请求，然后去验证cookie和session，如果验证成功，就向客户端返回请求的库数据

Session存储位置: 服务器内存，磁盘，或者数据库里
Session存储内容: id,存储时间，用户名等说明一下登录的用户是谁
客户端携带 ： cookie自动带，localStorage手动带

如何保存信息给浏览器

前端种
cookie/localstorage

后端种
服务器给浏览器种cookie: cookie-parser
服务器给浏览器种cookie的同时在服务器上生成seesion: cookie-session

cookie-session

安装引入

let cookieSession = require('cookie-session')

配置中间件

app.use(cookieSession({
	name:'保存到服务器的session的名字',
  keys:[必传参数，代表加密层级],
  maxAge:1000 //保留cookie的时间
}))

种cookie备份session

req.session.key = value

读取cookie对比session

req.session.key  返回true

删除cookie、session

delete req.session.key
//或者
req.session.key = undefined

简单的登录验证以及验证的时效性

let express = require('express')

let cookieSession = require('cookie-session')

let app = express()

app.use(express.static('./public'))

app.listen(3000)

app.use(cookieSession({
    name: "cookie",     //后端给前端种 cookie 的名字叫 cookie
    keys: ['aa','bb'],   //加密层级
    maxAge: 1000*20     //cookie 的失效时间
}))

//验证身份
app.get('/api/login',(req,res)=>{
    //校验客户端传递来的用户名与密码和数据库里面的是否一致
    //给客户端种 cookie 并且同时服务端留一份 session
    req.session.ss = 'id'
    //后端种完 cookie 后就可以给前端返回数据
    res.send({
        err:0,
        msg: "登陆成功！",
        data:{
            username: "李四"
        } 
    })
})

//自动登录功能
app.get('/api/user',(req,res)=>{
    //读取 cookie 对比 session
    //若前端传递来的 cookie 是有效的，则 req.session.ss 值就是 id           (true)
    //若前端传递来的 cookie 是失效的，则 req.session.ss 值就是undefined     (false)
    let pass = req.session.ss
    if(pass){
        //说明用户身份一直在，取库数据并且返回
        res.send({
            err: 0,
            msg: '已经登陆过',
        })
    }else{
        res.send({
            err: 1,
            msg: '登录已经过期'
        })
    }
    res.send()
})

//注销登录
app.get('/api/logout',(req,res)=>{
    //删除服务端 session 和客户端 cookie
    req.session.ss = undefined
    res.send()
})

token

思想
在服务端不需要存储用户的登录记录，全部发给客户端有客户端自己存(cookie,local)

1、客户端使用用户名跟密码请求登录
2、服务端收到请求，去验证用户名与密码
3、验证成功后，服务端会签发一个 Token（加了密的字符串），再把这个 Token 发送给客户端
4、客户端收到 Token 以后可以把它存储起来，比如放在 Cookie 里或者 Local Storage 里
5、客户端每次向服务端请求资源的时候需要带着服务端签发的 Token
6、服务端收到请求，然后去验证客户端请求里面带着的 Token，如果验证成功，就向客户端返回请求的数据

实现

jsonwebtoken

let jwt = require('jsonwebtoken')

生成签名

let token = jwt.sign(payload, secretOrPrivateKey, [options, callback])

[payload]: json 还有username,userid
[secretOrPrivateKey]: 加密规则，字符串，或者私钥path模块
[options]: 可选配置项
[callback]: 成功回调, 可选 返回制作后的token,也可同步返回

校验token

jwt.verify(token, secretOrPublicKey, [options, callback])

[callback]: 回调 err 错误信息 decode 成功后的信息
[options]: expiresIn 过期时间
[token]: 制作后的token
[secretOrPublicKey]: 解密规则，字符串，或者公钥

token删除

由客户端负责删除

session vs token

	session	token
服务端保存用户信息	√	×
避免CSRF攻击	×	√
安装性	一般	高
多服务器粘性问题	存在	不存在

多服务器粘性问题

当在应用中进行 session的读，写或者删除操作时，会有一个文件操作发生在操作系统的temp 文件夹下，至少在第一次时。假设有多台服务器并且 session 在第一台服务上创建。当你再次发送请求并且这个请求落在另一台服务器上，session 信息并不存在并且会获得一个“未认证”的响应。我知道，你可以通过一个粘性 session 解决这个问题。然而，在基于 token 的认证中，这个问题很自然就被解决了。没有粘性 session 的问题，因为在每个发送到服务器的请求中这个请求的 token 都会被拦截

实现token验证

//引入 express 模块
let express = require('express')

//创建 web 服务
let app = express()

//引入 body-parser 模块
let bodyParser = require('body-parser')

//引入 jsonwebtoken 模块
let jwt = require('jsonwebtoken')

//监听端口
app.listen(3000,() =>console.log('端口3000正在监听...'))

//使用 body-parser 模块
app.use(bodyParser())

//请求登录，服务端生成 token 令牌
app.get('/api/login',(req,res) =>{
    //获取 username password 进行数据库验证
    //生成 token 令牌
    let token = jwt.sign({
        username: req.query.username
    },'nz1906',{
        expiresIn: 60       //过期时间，按秒计算
    })

    // 将 token 和库信息返回给前端
    res.send({
        err: 0,
        msg: '用户登录成功',
        data: '库数据',
        token
    })
})


//校验 token
app.get('/api/user',(req,res) =>{
    //获取客户端传递来的 token
    let token = req.query.token || req.body.token || req.headers.token
    //校验 token
    jwt.verify(token,'nz1906',(err,decode) =>{
        console.log('err',err)
        console.log('decode',decode)
        //判断校验结果
        if(err){
            res.send({
                err: 1,
                msg: '登陆失败，token失效了'
            })
        }else{
            //校验成功数据返回前端
            res.send({
                err: 0,
                msg: '成功',
                data: '返回的数据'
            })
        }
    })
})

文件上传

思想

前端表单->后端接收到文件本身->保存到服务器上->给数据库记录文件一些信息->库返回给nodejs相关信息->nodejs返回给前端

前端: <input type=file enctype=“multipart/form-data” name=“fieldname”

实现

multer->文件名会随机->fs模块改名->path系统模块解析磁盘路径

后端：multer 接受 form-data编码数据

实现文件上传

let express = require('express')

let fs = require('fs')

let path = require('path')

let app = express()

app.listen(3000,()=>console.log('端口3000'))

//静态资源托管
//若用户想要在浏览器上面直接访问图片或者HTML页面。需要一个静态服务器
app.use(express.static('./public'))

//文件上传
//引入 multer 中间价
let multer = require('multer')

//实例化 multer
//dest: 指定保存位置（存到服务器）
let objMulter = multer({data:'./public/upload'})

//安装中间件
//运行上传什么类型文件  any 表示什么类型都可以
app.use(objMulter.any())

app.post('/api/reg',(req,res)=>{
    console.log(req.files)

    //需要进行文件的改名操作
    //fs.renameSync('改前','改后')
    let oldFile = req.files[0].path
    let newFile = req.files[0].path + path.parse(req.files[0].originalname).ext
    fs.renameSync(oldFile,newFile)

    //将地址返回给客户端
    res.send({
        err: 0,
        url: 'http://localhost:3000/upload/' + req.files[0].filename + path.parse(req.files[0].originalname).ext
    })
})

path系统模块

操作系统磁盘路径

编码

windows： c:\\user\\admin\\a.jpg
mac: ~/desktop/1901

UI呈现

windows: c:\user\admin
mac: ~/desktop/1901

API

磁盘路径解析 parse

path.parse('c:\\wamp\\xx.png') // string -> object

//返回
{
   root: 'c:\\', 盘符
   dir: 'c:\\wamp', 目录
   base: 'xx.png',  文件名
   ext: '.png', 扩展名
   name: 'xx' 	文件，不含扩展名
}

片段合并 join

path.join('磁盘路径1','磁盘路径2'，'磁盘路径n')

片段合并 resolve

path.resolve('磁盘路径1','磁盘路径n')

合并磁盘片段,右到左找根，左到右拼接，没有找到根，以当前文件路径为根

multer中间件

multer 接受 form-data编码数据,所有要求前端携带时注意一下，如：<input type=file enctype="multipart/form-data" name="fieldname"

使用

//1 引入
let multer  = require('multer');
//2 实例化  
let objMulter = multer({ dest: './upload' }); //dest: 指定 保存位置（存到服务器)
//安装中间件， 
app.use(objMulter.any());  //允许上传什么类型文件,any 代表任何类型 

中间件扩展了 req 请求 req.files

app.get('/reg',(req,res)=>{
  req.files
})

fieldname: 表单name名
originalname: 上传的文件名
encoding： 编码方式
mimetype: 文件类型
buffer: 文件本身
size：尺寸
destination: 保存路径
filename： 保存后的文件名 不含后缀
path： 保存磁盘路径+保存后的文件名 不含后缀

后端渲染

通常根据后端返回的json数据，然后来生成html被称为前端渲染，而后端渲染是后端把json与html结合渲染好后返回到浏览器，没前端什么事了

模板引擎

无论前后谁来渲染页面，都会用到模板引擎，前端渲染页面实际上是操作dom，后端渲染页面是把数据和html字符拼接后丢给浏览器

引擎	前端	后端
angularJs	√	×
vue/mustach	√	√
react	√	√
angularTs/mustach	√	√
jade/pug	×	√
ejs	×	√
jquery + art-template	√	×
handlerbars	√	×

jade

原理

fs抓取前端静态页面 + jade + 数据 -> 返回send(data) -> 浏览器

特点

侵入式，强依赖

使用

let jade = require('jade')
let html = jade.renderFile('jade模板文件'，{数据}，{pretty:true});	//返回字符

jade模板文件语法

父子要缩进
属性： 标签(key=value,key2=value)
内容: 标签 内容

其他扩展

ejs

原理

fs抓取前端静态页面 + ejs + 数据 -> 返回send(data) -> 浏览器

特点

非侵入式，温和，弱依赖

使用

let ejs = require('ejs')
ejs.renderFile('ejs模板文件',{要合并到html数据},回调(err,data))

err：错误，null代表没有错误
data: 渲染后的字符|流
ejs模板 ： 后缀名为ejs的html文件

ejs模板文件语法

• ejs 结构就是html
• 输出: <%= 数据名|属性名|变量名 + 表达式 %>
• 语句： <% 语句 %> 需要被<% %> 包裹
• 非转义输出: <%- 数据名|变量名 + 表达式 %>
• 载入公共：<%- include(’./hd.ejs’,{数据}) %>

其他扩展

多引擎管理

把多个模板引擎用在一个后端应用中，统一他们的用法，绑定到res、req身上

安装 + 配置

npm i consolidate ejs jade -S

注意：ejs jade 等多个引擎需要安装，但不需要引入

//中间件配置
app.set('view.engine','html');	//模板最终	输出类型设置
app.set('views','./views');		//引擎模板目录设置

app.engine('html',consolidate.ejs);	//输出与引擎匹配
app.engine('css',consolidate.jade);	//输出与引擎匹配

//渲染
app.get('xxx',(req,res)=>{
  res.render('模板文件名',{数据}) //整合页面和数据，完成渲染，发往浏览器,并结束响应
})

路由

---

告诉你去哪，对于前端，主要是导向告诉浏览器应该去哪，对于后端，可以理解为一个子服务，一个路由就是一个小的服务(server/app)，处理一个接口

配置和使用

routes/xx.js文件下

// 1. 创建路由
let router = express.Router(); 

//2 路由处理响应
router.响应API(地址, 处理函数)

//3. 导出路由
module.exports = router;

app.js文件下

//安装路由
app.use('地址',router); 

routes/xx.js文件下

//字路由里安装路由 嵌套
router.use('地址',子router) //需要next 延续

//截获当前路由下的部分公共业务
router.all('*',当前router路由下的验证工作) //需要next 延续

主路由的地址对应子路由的根
如：app.js :/api/user ~~ user.js: /
如: app.js: /api/user/add ~~ user.js: /add

数据库

---

MySQL

关系数据库、二维表、不存在子表

sql语句

建库

CREATE DATABASE  `2017-12-6` DEFAULT CHARACTER SET armscii8 COLLATE armscii8_general_ci;

建表

CREATE TABLE  `2020-12-6`.`user` (
					`name` VARCHAR( 32 ) NOT NULL ,
					`age` INT( 3 ) NOT NULL ,
					`address` VARCHAR( 128 ) NOT NULL
					) ENGINE = INNODB

增

INSERT INTO 表 (字段列表) VALUES(值列表)
INSERT INTO user (name,age,address) VALUES('苏菲',38,'')

删

DELETE FROM 表 WHERE 字段名=值
DELETE FROM user WHERE name='alex'

改

UPDATE 表 SET 字段名=值 WHERE 字段名=值
UPDATE user set name='sufei' WHERE name='苏菲'

查

SELECT ? FROM 表
SELECT * FROM user  查所有

node + mysql客户端

安装引入

npm install mysql -S
var mysql = require('mysql');

创建库连接

var connection = mysql.createConnection({
  host     : 'localhost',
  user     : 'root',
  password : 'root',
  database : 'user'
});
 
connection.connect();

库操作

connection.query('sql语句', function (error, results, fields) {
  if (error) throw error;
  console.log('The solution is: ', results);
});

results在增加、修改、删除的时候返回的是一个对象，而在查询的时候返回的是一个数组！

关闭库

connection.end();

mongodb

非关系型数据库，又叫nosql，缓存型，使用场景多是解决大规模数据集合多重数据种类

1. 下载 安装帮助

2. 配置数据文件存储位置：

   找到安装目录\Server\4.0\bin\  -> cmd回车-> mongod 回车->mongod --dbpath c:\data\db
   

   data和db目录要手动创建

3. 服务端启动：可选

   	找到安装目录\Server\4.0\bin\  -> cmd回车-> mongod 回车
   

   一般开启会默认启动

4. 客户端启动：

   找到安装目录\Server\4.0\bin\  -> cmd回车-> mongo 回车
   

5. 环境变量 可选

   为了在任意盘符下去都可以启动  mongod服务端|mongo客户端，把安装目录添加到环境变量
   

   MySQL vs mongodb

mysql	mongoDb
database(库)	database(库)
table(表)	collection(集合)
row(一条数据)	document(文档)
column(字段)	field(区域)
二维表，每次存到磁盘	json，存在缓存，关闭时存到磁盘	存储方式

mongodb 命令行操作 声明式 | obj.api()

库操作

在这里插入代码片查: show dbs
  	db 查看当前库
建:	use 库名	   没有建，有就切换
删: db.dropDatabase()  删除当前库

集合（表）操作

建：db.createCollection('表名',{配置})
  //配置：{size:文件大小,capped:true,max:条数|文档数} capped定量
  //db.表(集合).isCapped() 返回 true/false 是否是定量
查：show collections / db.getCollectionNames()
删：db.表|集合.drop()

文档（row）操作

---

增

db.集合.save({}) //添加一条
db.集合.insert({})  //添加一条
db.insertOne({}) //添加一条

db.集合.save([{},{}]) //多条
db.集合.insert([{},{}]) //多条
//insert  不会替换相同ID	save会

删

db.集合.deleteOne({要删数据条件描述}) //一条
db.集合.remove({},true)  //一条

db.集合.remove({要删数据条件描述}) //多条
db.集合.remove({}) //清空表

改

db.集合.udpate({查询条件},{替换条件},插入boolean,全替换boolean)

查询条件

{age:22} age == 22
{age:{KaTeX parse error: Expected 'EOF', got '}' at position 6: gt:22}̲} age > 22 {a…lt:22}} age < 22
{age:{KaTeX parse error: Expected 'EOF', got '}' at position 7: gte:22}̲} age>=22 {ag…lte:22}} age<=22
{age:{$lte:122,$gte:22}} age<=122 && age>=22
{$or:[{age:22},{age:122}]} 22 or 122
{key:value,key2,value2} value && value2
{name:/正则/}

替换条件
{$set:数据,$inc:{age:1}}

查

所有：db.集合.find(条件)
条数: db.集合.find().count()
去重：db.集合.distinct(key)

db.集合.find({条件},{指定要显示列区域})

指定要显示列区域
username:1 显示这个区域，其他不显示
username:0 不显示这个区域，其他显示
_id 是默认显示

排

db.集合.find().sort({key:1,key2:-1}) //升
db.集合.find().sort({key:-1})	//降

限定

db.集合.find().limit(number)  //限定
db.集合.find().skip(number)	//跳过
db.集合.findOne()//找第一个
db.集合.find().limit(1)  //查询第一条

node + mongodb客户端

安装引入

npm install mongodb -S
var mysql = require('mongodb');

实例化并连接

let mongoCt = mongodb.MongoClient;
//err 错误 client链接后的客户端
mongoCt.connect('协议://地址:端口',回调(err,client)) 

链接库和集合

在这里插入代码片let db = client.db('库名')
let user = db.collection('集合名');

集合操作

//user.API()  集合操作 	返回 对象

//增
	insertOne(对象数据,(err,res)=>{})  //res = 对象  
	insertMany(arr数据,(err,res)=>{}) //res = 对象  
    //res.result.n 结果  ok 状态
    //res.ops内容  数组
    //result.insertedId 插入后的id

//删:
  deleteOne({条件},(err,result)=>{})

//改:
  updateOne({条件},{更新后},(err,res)=>{})
  updateMany({条件},{更新后},(err,res)=>{})
  updateMany({条件},{更新后},{配置},(err,res)=>{})
    //配置: upsert:true 插入	projection:true 全局替换
//查:
  user.find({条件},{skip:1,limit:1,projection:{key:1}},(err,result)=>{result=对象})
  user.find({条件},{projection:{key:0}}).toArray((err,result)=>{reulst==arr})
  user.countDocuments((err,num)=>{num返回数量})

//排
  user.find(..).sort({key:-1}).toArray..
  user.find({},{projection:{},sort:{key:-1}}).toArray..

关闭库

client.close()

Express 生成器

---

应用程序生成器、脚手架、命令行工具、自动搭建项目环境的、无需手动

安装

npm install express-geneerator -g

验证

express -h

生成环境

express -e 目录 | . 
	// . 当前目录创建 
	//-e 需要ejs模板引擎
	//express -f  强制在非空目录下创建
cd 目录
npm install 		//安装依赖包
npm start    
node ./bin/www

扩展