node第一周总结

初识node

介绍

用来写后台管理程序的，JS的运行环境。可以用来提供数据服务、文件服务、seb服务

目标

数据服务、文件服务、web服务

优势

性能高，方便、入门难度低、大公司都在用（BAT）

劣势

1. 服务器提供的相对较少
2. 相对其他语言，能用的上的学习资料少
3. 对程序员的要求高了

环境安装

安装
测试环境：win+r->命令行(运行->cmd)->node -v
开发工具：
HBuilder
VSCode

注意：nodejs是ECMA语法，不能使用DOM、BOM

web服务器

构成

机器、数据库、管理程序

前后端交互

大后端： 用户 - > 地址栏(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模块

磁盘操作，文件操作
引入 let fs= require('fs')
读取 fs.readFile('文件路径',[编码方式],(err,data)=>{})
更名 fs.renameSync('改前','改后');
删除 fs.unlinkSync('文件路径')

url模块

引入 let url = require("url")
使用方法： url.parse(str,true) 返回 对象 true处理query为对象

querystring模块

处理查询字符串
引入 let querystring = require("querystring")
返回对象 querystring.parse(str)
返回字符串 querystring.stringify(obj)

npm-包管理器

帮助我们安装模块（包），对用户所需的一系列包进行管理
安装到全局环境 npm i 包名 -g
卸载 npm uninstall 包名 -g
-g代表的是安装到全局环境 global
初始化项目环境 npm init
初始化npm管理文件：pack.json

yarn-包管理器

yarn是为了弥补npm的一些缺陷而出现的一个包管理器
使用方法与npm类似
初始化项目yarn init
添加依赖包：
yarn add [package]
yarn add [package]@[version]
yarn add [package]@[tag]
升级依赖包：
yarn upgrade [package]
yarn upgrade [package]@[version]
yarn upgrade [package]@[tag]
移除依赖包：
yarn remove [package]
安装全部依赖：
yarn

bower-包管理器

Bower能对前端框架，前端库，资源和 common代码进行管理
安装：npm install -g bower
安装包到全局环境：bower i 包名 -g
卸载：bower uninstall 包名 -g
初始化项目：bower init

express-web开发框架

Express 是一个基于 Node.js 平台的极简、灵活的 web 应用开发框架，它提供一系列强大的特性，帮助你创建各种 Web 和移动设备应用。
特点：二次封装、非侵入式、增强形
搭建web服务：
let express=require('express')
let server=express()
let server.listen(端口,地址,回调)
静态资源的托管：
server.use(express.static('./www'));

express的接口响应

支持了各种请求 POST、GET等…

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

req

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

1. req.query 获取地址栏的数据
2. req.body 获取非地址栏的数据 依赖中间件
3. req.params 获取动态接口名
4. req.method 获取前端提交方式

res

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

1. res.send(any) 对等 res.write + end
2. res.end(string|buffer)
3. res.json(json) 返回json
4. res.status(404).send({error:1,msg:“Sorry can’t find that!”}) 返回一个404
5. res.jsonp(响应数据) 调用请求时的回调函数并传递响应数据
6. res.sendFile(path.resolve(‘public/error.html’)) 渲染纯 HTML 文件

next()

next() 函数的作用主要是确保所有的中间件都执行，如果没有 next() 那么这些代码就会被挂起，不会执行

ajax和jsonp

ajax和jsonp的请求及响应

<script>
    window.onload = function(){
        //客户端发起jsonp请求
        /*jsonp({
            url:"http://localhost:8080/api/home",
            data:{start:10,end:10},
            success:(data)=>{
                console.log("获取数据",data)
            }
        })*/

        /*ajax({
            url:"http://localhost:8080/api/login",
            data:{start:520,end:524},
            success:data =>{
                console.log("ajax获取数据",data)
            }
        })*/
    }
</script>

const express = require("express")
const bodyParser = require("body-parser")

//创建web服务器
const app = express()

//监听端口
app.listen(8080,"localhost",()=>{
    console.log("端口8080正在监听...")
})

//资源托管
app.use(express.static("./public"))

//使用中间件
app.use(bodyParser())

//接口响应
/*app.get("/api/goods",(req,res)=>{
    console.log("处理了api接口",req.query)
    //res.send("你好")
    //res.json("{a:1,b:2}")
    res.status(404).send({error:1,msg:"sorry no find that"})
})*/

//post请求传递的参数body获取不到,需要使用中间件body-parser
/*app.post("/api/goods",(req,res)=>{
    console.log(req.body)
   res.end()
})*/

//请求动态id req.params.id
/*app.get("/api/goods/:id",req=>{
    console.log("详情....",req.params.id)
})*/

//接口响应
/*app.get("/api/home",(req,res)=>{
    console.log("返回一个静态页面...")
    res.sendFile(path.resolve('public/index.html'))
})*/

//响应jsonp数据
/*app.get("/api/home",(req,res)=>{
    res.jsonp({error:0,data:{a:1,b:2}})
    console.log(req.query)
})*/

//ajax
app.get("/api/login",(req,res)=>{
    console.log("ajax",req.query,req.body)
    res.send({err:0,data:{msg:"ajax请求..."}})
})

我们可以直接拿到客户端的一些数据，服务端可以对这些数据进行处理

use中间件

中间件其是一个函数，在响应发送之前对请求进行一些操作
一个请求发送到服务器后，它先收到request（请求），然后服务端处理，处理完了以后发送response（响应）回去，为了明确和便于维护，需要把处理的事情分一下，分配成几个部分来做，而每个部分就是一个中间件

使用中间件的三个步骤：

1. npm i body-parser -S 安装包
2. let bodyParser=require(‘body-parser’) 引入中间件
3. server.use(bodyParser()) 安装中间件

后端实现跳转，页面报错或更改地址后实现一个跳转：
res.redirect(url) 指向一个接口

session实现一个身份验证/过期问题

let express = require("express")

let cookieSession = require("cookie-session")

let app = express()

//使用中间件
app.use(cookieSession({
    keys:["aa","b","cc"],//加密层级
    name:"mycookie",//后端给前端cookie的名字
    maxAge:1000*30//设置失效时间
}))

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

app.listen(8080)

//验证用户身份
app.get("/api/login",(req,res)=>{
    console.log("进来了...")
    //1.校验客户端用户名及密码和数据库是否一致
    //2.给客户端种一个cookie，服务端会留一份session
    //console.log(req.session)
    req.session.nz1906 = "userId"
    //3.后端种完cookie后，就可以给前端返回数据
    res.send({
        err:0,
        mas:"恭喜你，登陆成功",
        data:{
            username:"张三"
        }
    })
})

//自动登陆
app.get("/api/user",(req,res)=>{
    //读cookie，对比session
    let pass = req.session.nz1906 //如果用户登陆了，pass就拿到了userId
    console.log(pass)
    if(pass){
        //登陆成功,从数据库取数据
        res.send({
            err:0,
            data:"/api/user的数据"
        })

    }else{
        res.send({
            err:1,
            data:"用户未登陆"
        })
    }
    res.end()
})

//注销
app.get("/api/logout",(req,res)=>{
    req.session.nz1906 = undefined
    res.end()
})

我们先使用express获取到客户端的数据，然后对这个cookie进行验证。服务端留一份session。在一定时间段内，用户可以登陆到页面，后端对用户身份进行验证及cookie存在时间的控制，用户也可以自动进行销毁cookie

path系统模块

用来操作系统盘路径 windows编码：c:\\user\\admin\\a.jpg mac编码：~/desktop/1906

磁盘路径解析parse

path.parse('c:\\wamp\\xx.png')

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

返回的对象中有一些属性可以给我们提供一些使用上的便利

片段合并join

可以给几个片段合并成一个完整的路径：join是把各个path片段连接在一起， resolve把‘／’当成根目录
path.join('磁盘路径1','磁盘路径2'，'磁盘路径n')
__dirname 魔术变量 返回当前文件所在的磁盘路径

片段合并resolve

resolve在传入非/路径时，会自动加上当前目录形成一个绝对路径，而join仅仅用于路径拼接
path.resolve('磁盘路径1','磁盘路径n')

const path = require('path');
let myPath = path.join(__dirname,'/img/so');
let myPath2 = path.join(__dirname,'./img/so');
let myPath3 = path.resolve(__dirname,'/img/so');
let myPath4 = path.resolve(__dirname,'./img/so');
console.log(__dirname);   //D:\myProgram\test
console.log(myPath);     //D:\myProgram\test\img\so
console.log(myPath2);   //D:\myProgram\test\img\so
console.log(myPath3);  //D:\img\so<br>
console.log(myPath4); //D:\myProgram\test\img\so

multer中间件

multer是一个node.js中间件，用于处理 form-data编码数据，主要作用是上传文件

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

简单的应用案例

let express = require("express")
let multer = require("multer")
let fs = require("fs")
let path = require("path")

let app = express()

app.listen(8080,()=>console.log("8080端口正在监听..."))

//静态资源托管
app.use(express.static("./www"))

//文件上传
let objMulter = multer({dest:'./www/upload'})

//使用multer中间件
app.use(objMulter.any())//any允许上传什么类型的文件

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

    //上传后更改名字
    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:8080/upload/"+req.files[0].filename + path.parse(req.files[0].originalname).ext
    })
})

可以上传任何类型的文件，并获取名字后更改名字
fieldname: 表单name名

1. originalname: 上传的文件名
2. encoding： 编码方式
3. mimetype: 文件类型
4. buffer: 文件本身
5. size：尺寸
6. destination: 保存路径
7. filename： 保存后的文件名 不含后缀
8. path： 保存磁盘路径+保存后的文件名 不含后缀

后端渲染

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

jade

原理：fs抓取前端静态页面 + jade + 数据 =>返回send(data) => 浏览器
特点：侵入式，强依赖
使用：

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

语法格式 jade后缀文件：

html
    head
    body
        div(class="list")
            ul
                li(class="active")
                    a(href="http://www.baidu.com") 这是a连接哦....

        div 我是一个div... 
            h1 #{data}

ejs

原理：fs抓取前端静态页面 + ejs + 数据 => 返回send(data) => 浏览器
特点：非侵入式、温和弱依赖
使用：

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

语法格式ejs后缀文件
实现一个文件引入，利用 include
<%- include('./hd.ejs',{title:"你好"}) %>

<body>  

    <%- include('./hd.ejs',{title:"你好"}) %>

    <h1><%=title %></h1>
    <h3><%=age+1 %></h3>

    <%
        var a = 3
        var b = 4
        var c = a+b
    %>
    <% var d = 10 %>
    <% var e = 20 %>
    <% f = d+e %>

    <% if(bool){%>
        <nav>渲染nav1这个导航....</nav>
    <% }else{ %>
        <nav>渲染nav2这个导航....</nav>
    <%}%>

    <div>c====> <%=c %></div>
    <div>c====> <%=f %></div>

    <ul>
        <% for(var i=0;i<list.length;i++){ %>
            <li><a href="<%= list[i].href%>"><%=list[i].des %></a></li>
        <% } %>
        
    </ul>


    <div>
        <% for(var i=0;i<list.length;i++){ %>
            <p><a href="<%= list[i].href%>"><%=list[i].des %></a></p>
        <% } %>
    </div>
</body>

mongobd非关系型数据库（nosql）

库的操作

查询所有库：show dbs
查看当前数据库 : db
创建库：use 库名 （没有此库就是新建库 有就切换）
删除库：db.dropDatabase() 删除当前库

集合的操作

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

文档操作

增

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)
//将所有的用户名为李四的年龄全都设置为20岁
db.user.update({username:“李四”},{$set:{age:20}},false,true)
第三个参数：如果更新的数据没有的话则插入，默认不插入 第四个参数：默认只更新一条数据，如果要批量更新设置true

查

所有：db.集合.find(条件)
条数: db.集合.find().count()
去重：db.集合.distinct(key).length db.
集合.find({条件},{指定要显示列区域})

排

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) //查询第一条