DAY01 HELLO ,NODEJS

------------------------------

服务器端的语言有什么？
   1.进行http通信
   2.操作数据库，对数据库进行增删改查，
   3.操作本地文件

Nodejs 有什么特点？
   javascript的运行环境
   非阻塞I/O
   单线程
   事件驱动

Nodejs的事件驱动？
   接受客户端的请求
   对文件进行读写
   操作数据库

什么是非阻塞I/O
在执行I/O的过程时候，不会等待其应用程序执行完成后在执行其他应用程序，当I/O结束后，在回头处理这个结果。即异步

单线程
程序按照逻辑顺序执行，前面的必须处理完成，后面的才会执行，即在同一个时间里面只能做一件事情

-------------------------
repl 交互环境
退出ctrl+c

cls 清屏
dir 查看当前目录
cd change directory 切换目录

cd .. 返回到上一层目录

查看你的版本号 node -v

查看npm版本号 npm -v

---------------------------
let 声明变量

   1. 不可以变量提升
   2. 声明的变量不可以再次声明，但是可以重新复值
   3. 可以形成一个块级作用域

const 常量

   1. 不可以常量提升
   2. 声明的常量不可以再次声明，也不可以重新赋值(常量存储的地址不可以发生改变)
   3. 可以形成一个块级作用域

浏览器的特点

发送请求接受请求处理请求(渲染页面)

服务器的特点

接受请求处理请求(操作数据库) 响应请求

javascript

全局对象 window

nodejs
全局对象 global

模块

一个功能的集合一个模块一般情况下是一个对象(含有方法和属性)

content-type 内容类型，相当于告诉浏览器采用什么方式来解析文件

===============================================

DAY02 URL 、querystring

http状态码

200请求成功

304缓存

404文件找不到

403 forbidden

5-- 服务器错误

url模块
-------------------------------------
req.url 表示用户的请求地址所有的路由设计都是通过req.url来完成的，so is very important

我们关心的是如何处理这个url，而不是拿到这个url

# 如何把url里面的信息转换为一个对象,通过对象可以方便以后操作？正则表达式

url 模块处理请求路径

url.parse(参数一，参数二，参数三) 将一个url的字符串解析并返回一个url的对象

# 参数一 url(字符串)
# 参数二布尔值默认为false ，为true时，返回的对象中，query的属性为一个对象可省略
# 参数三布尔值解析主机处理一般情况下使用不到

返回的对象说明：

protocol: 请求协议

　　host: URL主机名已全部转换成小写, 包括端口信息

　　auth:URL中身份验证信息部分

　　hostname:主机的主机名部分, 已转换成小写

　　port: 主机的端口号部分

　　pathname: URL的路径部分,位于主机名之后请求查询之前

　　search: URL 的“查询字符串”部分，包括开头的问号。

　　path: pathname 和 search 连在一起。

　　query: 查询字符串中的参数部分（问号后面部分字符串），或者使用 querystring.parse() 解析后返回的对象。

　　hash: URL 的 “#” 后面部分（包括 # 符号）

url.format(参数为对象)

# format函数的作用与parse相反，将一个，返回一个url路径地址(字符串)

在返回的结果看不到如http，https等协议，返回的结果为 ://

url.resolve(from,to) 函数的参数是两个路径，第一个路径是开始的路径或者说当前路径，第二个则是想要去往的路径，返回值是一个组装好的url

# 注意只能重定向路径名，不能重定向域名
# 没有多大用，一般用字符串拼接就可以完成

path.extname() 方法返回 path 的扩展名，即从 path 的最后一部分中的最后一个 .（句号）字符到字符串结束。如果 path 的最后一部分没有 . 或 path 的文件名（见 path.basename()）的第一个字符是 .，则返回一个空字符串。

path.extname('index.html');
// 返回: '.html'

path.extname('index.coffee.md');
// 返回: '.md'

path.extname('index.');
// 返回: '.'

-----------------------------------------
querystring 模块

# querystring 模块提供序列化与反序列化，转义与反转义两组功能

1. querystring.stringify()
将一个对象序列化为一个查询的字符串,使用&和=分别为字符串中的分割符合赋值符

# 如果转换的对象中有中文会对中文进行unicode编码
# stringify 中的第2个参数是用来修改 & 分隔符为其他符号
# stringify 中的第三个参数修改默认的 & 分隔符为其他符号

2. querystring.parse()
将一个查询的字符串反序列化为对象，与querystring.stringlfy()的作用相反

# 第2个参数是用来指明分隔符是用了哪个字符,根据分隔符来进行反序列化
# 第三个参数是用来指明赋值分隔符是哪个字符

3.querystring.escape()
将字符编码

4.querystring.unescape()
将字符解码

04.js 案例讲解如何拿到路径部分想要的数据

-------------------------
05.js 模拟form表单发送请求给nodejs服务器，nodejs处理接受到的数据

06.js
做一个学生和老师的管理系统
当用户访问 /student/0123456789 10位数这个路径地址时候查询此学生的学生信息
当用户访问 /teacher/123456 6位数时候查询老师的相关信息
请他路径情况，提示信息输入错误，如果是位数不对，提示位数不对

07.js 把一个项目完整的读取出来
一般一个项目里面包含有html css javascript 图片三种类型的文件

对应的mime类型分别为
html text/html
css text/css
javascript text/javascript
image image/jpg image/png

http://www.w3school.com.cn/media/media_mimeref.asp 文件mime类型

DAY03 FS 、path 、 buffer

=============================================================
--------------------------------------
fs模块详解

1. 异步讲解

让学生访问电脑，看异步函数的结果

--------------------------------

fs.mkdir(path,[mode],callback(err));

fs.rmdir(path,callback(err));

4. 读取目录
fs.readdir(path,callback(err,files));

# files 返回的是数组，内容为文件名或者文件夹名

5. 修改目录或者文件名
fs.rename(path1,path2,callback(err))

------------------------------
文件的操作(增删改查)

6. 文件读取

fs.readFile(file [,options],callback);

# file 文件名
# options
encoding 默认为空，一般设置为utf8
flag 标识符默认为r r代表以读取模式打开文件

7. 写入文件

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

# 如果文件不存在会先创建文件
# 默认采用utf-8 编码

8. 追加文件

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

9. 删除文件
fs.unlink(file,callback);

10. 监听文件发生改变

fs.watchFile(filename,callback(newStatus,oldStatus));

# 一旦文件发生变动就会自动触发回调函数

可以采用这个监听文件的原理来完成自动重新运行服务器

安装插件supervisor 原理就是监听文件发生了变化，一旦文件发生了变化就会重新启动node程序

# 异步操作是非常难以控制的可以采用promise对象进行解决

10. 查看文件或者文件夹的状态可以获取文件大小，创建时间等信息
fs.stat(file,callback(err,status))

----------------------------------------
path 模块详解

path.normalize(路径名) 格式化路径

path.join(路径一，路径二，路径三....) 路径的拼接

path.resolve(路径一，路径二，路径三，....) 绝对路径

# eg : path.resolve("aa/bb","cc/dd","../aa");

# 相当于在cmd光标目录下执行以下操作
cd aa/bb
cd cc/dd
cd ../aa
pwd

path.dirname(文件路径); 获取文件或者文件夹所在的目录

path.basename(路径名) 获取文件的文件名第二个参数可以忽略掉文件后缀名

path.extname(文件名) 获取文件的后缀名

path.parse(路径) 解析路径为对象

Buffer 缓冲区
--------------------------------------
什么是Buffer
Buffer是用来存储二进制数据的对象但是结果以16进制的形式表示出来
# Buffer是一个类数组对象，不是数组

Buffer的作用
javascript能够处理字符串，对字符串进行一些操作，但是对于一些二进制数据就没法操作了。
buffer是用来处理二进制文件流和TCP流(http的底层协议)的文件缓存区，可以将二进制流和string进行相互转换

Buffer的特点
buffer对象里面存储的是字节，而不是字符串或者其他的数据类型主要热点是用来操作字节的
Buffer是一个类数组对象

什么时候用到buffer
用到数据流的地方就会用到buffer(比如文件读取，http中post请求传递的数据)

# EF BB BF 微软在自己的UTF-8格式的文本文件之前加上了EF BB BF三个字节用来检测一个字节流是否是UTF-8编码的

创建一个buffer对象
var buf = Buffer(字符串);

将一个buffer对象转换为字符串
var str = buf.toString();

-----------------------------------------
流操作(stream) 一般代表文件读写操作

为什么要有流操作

如果读取或者写入一个比较大的文件如(音频或者视频一般为几个G左右)，如果使用writeFile或者readFile来操作，非常容易使电脑内存"爆仓"，因为电脑内存一般也就4G，8G左右

理想的方法应该是分多次对数据进行读写操作，不管文件有多大，只要时间允许，总会处理完成。这时后就需要有流操作了

什么是流

把一个文件比喻成一个水桶，文件里面的内容比作为水，我们用一根管子(pipe)连接两个桶使得水从一个桶流入另一个桶，这样就慢慢的实现了大文件的复制过程(也就是流的过程)。

可读流

从文件读取数据时，可以打开一个文件流，然后从文件流中不断地读取数据

var readStream = fs.createReadStream("文件名")

创建一个可读流

readStream.on('data',callback(chunk));

当有数据流出时自动触发data事件，数据存储在chunk中

readStream.on("end",callback)

当数据读取完毕后自动触发end事件

readStream.on("error",callback(err));

当读取发生错误的时候自动触发error事件

可写流

向文件写入数据时，只需要把数据不断地往文件流中写进去就可以了

var writeStream = fs.createWriteStream("文件名")

创建一个可写流

writeStream.write("写入内容");

向文件中写入内容 # 要写入多个内容，只需要不断调用这个函数就可以了

writeStream.end();

写入完成

# 流的过程是可以暂停和重启的键案例04.js

readStream.pause() 暂停可读流
readStream.resume() 继续可读流

writeStream.on("drain") 监听可写流完成后触发事件

stream.write(chunk) 返回一个布尔值如果为true代表写入流完成，false代表未完成

#所有可以读取数据的流都继承自stream.Readable，所有可以写入的流都继承自stream.Writable

pipe(管道)

将可读流和可写流串联起来，一个Readable流和一个Writable流串起来后，所有的数据自动从Readable流进入Writable流，这种操作叫pipe，这样源文件的所有数据就自动写入到目标文件里了

# pipe自动调用了data,end等事件

创建一个压缩文件

# 创建一个可读流

var readStream = fs.createReadStream("文件名");

# 创建一个可压缩和解压流

var zilb = require("zlib");
var gzip = zlib.createGzip();

# 创建一个可写流

var writeStream = fs.createWriteStream("文件名");

# 通过中间管道进行压缩然后写入到可写流中

readStream.pipe(gzip).pipe(writeStream);

DAY04 NPM

npm install 模块名下载模块
npm uninstall mokuai 删除模块
npm install 模块名 --save 在package.json 文件当中添加依赖
npm install 代表从package.json文件中下载想对应的依赖

DAY05 GET 和 POST ejs 模板引擎

get请求和post请求的区别

get请求

# 请求的参数附加在url地址后面
# get请求传输的数据有限，不能用于图片上传等数据传递
# GET请求的数据会被浏览器缓存起来
# get请求的请求头中的content-type无
# 在nodejs服务器端，获取数据采用url.parse(请求地址).query拿到数据

post请求

# 请求的参数放在请求体当中
# post请求传递的数据比get请求大得多，可以进行图片上传等数据传递
# post请求的数据不会被浏览器缓存起来
# get请求的请求头中的content-type为application/x-www-form-urlencoded
# 在nodejs服务器端，获取数据采用可读流的形式拿到数据

@@ 为什么post请求采用可读流的形式拿到数据？

# node为了追求极致，它是一个小段一个小段接收的,接受了一小段，可能就给别人去服务了。防止一个提交过大的数据阻塞了整个进程

------------------------------------
模板引擎 EJS

1. EJS 模板引擎为后台程序模板，相对应的前台程序模板有三大框架vue reactNavite angular

2. EJS 模板引擎是npm的第三方模块

3. 后台模板，著名的有两个，第一个叫做ejs；第二个叫做jade(书写困难，严格的缩进)

4. 模板引擎的原理

# 使用正则表达式，将模板中的指定内容进行正则匹配替换为其他内容，实现数据绑定，最终形成一个完整的html字符串

5. ejs指定内容的格式为 <%= 对象的属性名 %>

6. ejs 模板可以进行简单的赋值逻辑判断与循环如：

# <a href="<%= url %>">

# <img src="<%= imageURL %>" alt=""></a>

#
<ul>
<% for(var i = 0 ; i < news.length ; i++){ %>
<li><%= news[i] %></li>
<% } %>
</ul>

7. 模板引擎的用法

7.1 引入模板ejs模块

7.2 创建ejs模板

7.3 创建替换内容

7.4 数据替换

# ejs.render(模板，替换数据，配置选项)

8. 后台模板引擎的缺点

8.1 在不久将来，会退出历史舞台

# 前后台没有完全分离 (前台处理页面，后台处理数据)

8.2 实现数据动态的改变非常困难

# 下拉刷新加载更多

DAY06 express 框架

ES6对象的简写方法
---------------------------------------
1. 对象的简写方法
1.1 如果对象的属性名和属性值同名，对象的属性可以简写为如下：

eg：

var name = "laowang";

var obj = {name:name}; => var obj = {name}

2.2 对象的方法可以简写为

eg1:
var obj = { getName:()=>{}};

eg2:
var obj = { getName(){}};

eg3: function getName(){} var obj = {getName};

2. 字符串模板

eg：
var name = "laowang";
var str = `哈哈，${name}我爱你`;
console.log(str)
输出结果: 哈哈，老王我爱你

原理：正则表达式的替换

优点：相比字符串和变量拼接，非常方便

-----------------------------------------
NodeJs 之 Express 框架

1. 什么是express

# Express框架是后台的javascript框架

2. 为什么要使用express

原生Node开发，会发现有很多问题。比如：
呈递静态页面很不方便，需要处理每个HTTP请求，还要考虑304问题
路由处理代码不直观清晰，需要写很多个条件分支

总之：不能集中精力写业务，要考虑很多其他的东西

所以，express可以帮助我们解决上述问题

3. 安装Express框架，就是使用npm的命令。

方法一：npm install --save express

方法二：npm install express --save

# --save参数，表示自动修改package.json文件，自动添加依赖项

4. 路由

app.get("路由路径",callback(req,res));

# 当用get请求访问一个网址的时候，做什么事情

app.post("路由路径",callback(req,res))

# 用post访问一个网址的时候，做什么事情

app.all("路由路径",callback(req,res));

# 不管是get请求还是post请求都会处理这个路由路径

路由模糊匹配

app.get("/:teacher/:number",callback(req,res));

# 表示模糊匹配路由路径内容，可以匹配任何路由路径的形式为/sfdsfdsf/sdsfsf
# 可以把teacher和number当做变量然后通过req.params 来拿到值
# req.params为对象通过teacher和number变量来拿到teacher和number变量的值

注意：
1. 路由路径，可以忽略大小写

2. 可以采用链式调用方法处理不同的路由

3. res.send() 可以发送任何数据类型的数据

4. 如果想使用不同的状态码，可以：

res.status(404).send('内容');
5. 如果想使用不同的Content-Type，可以：

res.set('Content-Type', 'Mime类型');

5. send() 发送的数据类型可以有多种，原生的nodejs发送的数据类型只能为字符串或者buffer

5.1 send("字符串")

# 自动添加请求头text/html

5.2 send(数组或对象)

# 自动添加请求头application/json

# json 是一种数据传输格式，json包含有json数组和json对象
# 在发送对象或者数组的时候已经将数组或者对象进行转换为json字符串了

5.3 send(buffer)

# 自动添加请求头 applicaiton/octet-stream

6. 为什么res.send() 内容为buffer对象的时候浏览器会下载？

因为在send的时候，express会自动识别内容，然后添加相对用的content-type类型
当发送的内容为buffer对象的时候，添加的content-type类型为 application/octet-stream，
而这个流是一个不能被浏览器解析的流，必须被下载

7.静态文件处理

app.use(express.static("文件夹"));

8. 模板引擎

需要在应用中进行如下设置才能让 Express 渲染模板文件：

views, 放模板文件的目录，比如： app.set('views', './views') 默认为这个目录
view engine, 模板引擎，比如： app.set('view engine', 'ejs')

9. 在express中路由路径的匹配是从上往下匹配的，如果有一个匹配成功，就不会再去匹配下面的路由路径，
这个时候如果想让他继续去匹配其他的路由就需要使用next中间件了

eg：
app.get("/",(req,res,next))

如何理解中间件的作用？

# 中间件可以预先处理所有请求再转交给特定的路由来进行处理。

10. app.use();

# 匹配路由前缀，只要前缀匹配成功，那么所有的路由都会被执行

# 当路由路径为根路径的时候，express规定路由路径参数可以不写

11. GET请求和POST请求的参数

11.1 get请求

GET请求的参数在URL中，在原生Node中，需要使用url模块来识别参数字符串。在Express中，不需要使用url模块了。可以直接使用req.query对象。

12.2 post请求

POST请求在express中不能直接获得，必须使用body-parser模块。使用后，将可以用req.body得到参数。但是如果表单中含有文件上传，那么还是需要使用formidable模块

DAY07 mongoDB数据库

数据库 databases
--------------------------------------------

1.1 数据库的作用

# 存储数据

1.2 数据库的分类

1.2.1 结构型数据库也叫关系型数据库

MySQL、SQL Server、Oracle、Access等等

采用SQL语言，管理数据库

结构型数据库的特点

# 数据库里面有表，表有行和列的概念，每个表中，都有明确的字段，每行记录，都有这些字段。不能有的行有，有的行没有。

1.2.2 非结构型数据库

mongodb

非结构型数据库的特点

# 没有行、列的概念。用JSON来存储数据

# 集合就相当于“表”，文档就相当于“行”

# 文档就是json 可以通过javascript进行操作

为什么不用txt文档或者excell来存储数据

# 当数据比较大的时候，对文档的读取是一次性读取，内存不够，而数据库读取是分段读取的
# 增删改查不方便

结构型数据库和非结构型数据库的不同点

结构型数据库存储数据不灵活，一个字段，需要是同样类型的数据。不能一行记录字符串，一行记录是数字。

非结构型数据库的特点：

# 数据模型比较简单
# 对数据库性能要求较高
# 不需要高度的数据一致性

----------------------------
mongodb 安装

1. 下载 https://www.mongodb.com/download-center#community

安装过程中可以对安装路径进行更改，建议不更改

# 数据库的运行文件的位置和数据库存储的位置不是一回事

2. 安装成功后添加环境变量

eg：将mongo的bin目录 C:\Program Files\MongoDB\Server\3.0\bin 加入到系统的path环境变量中

为什么要添加环境变量

# 可以在不同的目录下执行mongodb的相关应用操作

3. 环境变量添加成功后，可以在系统的任何盘符，使用mongo的命令了

4. 常用命令操作

mongod 开启数据库

mongo 操作数据库

mongoimport 导入数据库

5. 开启数据库

在32位操作系统中执行以下操作

mongod --dbpath C:\data --storageEngine=mmapv1

在64位系统中

mongod --dbpath C:\data

注意：

# 如果光标挂起，说明数据库开启成功

# --dbpath就是选择数据库文档所在的文件夹

# --storageEngine=mmapv1 指定存储格式，64位不需要指定

# 在mongoDB中，有物理文件对应一个个数据库，U盘可以拷走以ns结尾的文件即为数据库。

6. 操作数据库执行mongo 命令

# 一定要确保在操作数据库之前数据库已经开启了，不能关，不能ctrl+c。一旦这个cmd有问题了，数据库就自动关闭了。

######################

以上操作步骤，可以创建n个不同目录下的数据库存储的地方，每次开始数据库都要执行以上操作，比较麻烦，为了简化操作，可以让mongodb成为电脑的服务,那么采用开始mongodb服务每次都能快速启动数据库，并且进入到指定的数据库存储的地方注意以管理员的方式进行安装

32位操作系统：

mongod --dbpath "C:\data\db" --logpath "C:\data\log\log.txt" --serviceName "MongoDb" --serviceDisplayName "mongodb" --journal --storageEngine=mmapv1 --install

64位：

mongod --dbpath "D:\Mongodb\data\db" --logpath "D:\Mongodb\data\log\log.txt" --serviceName MongoDB --install

# --serviceName 服务名称建议MongoDB
# --serviceDisplayName window组件的显示名称可以跟服务名称不一致

# 移除服务将install改为remove即可

2.然后启动必须在管理员的权限下启动

net start MongoDB 启动mongodb

net stop MongoDB 关闭mongodb

##############################

7. 操作数据库的相关指令以下操作是mongodb的语法

7.1 show dbs

# 列出所有的数据库

7.2 use 数据库名字

# 使用某个数据库
# 如果use一个不存在的，就是新建一个数据库

7.3 db

# 查看当前所在数据库

7.4 db.students.insert({"name":"laowang","age":100});

# 向当前数据库所在的集合中插入一条数据

# db 表示当前所在的数据库

# students 代表是一个集合，一个数据库里面可以有很多个集合

# students第一次使用，集合将自动创建，集合中存储的每一条json数据叫做文档

7.5 show collections

显示当前数据中的集合

7.6 db.students.find()

查看当前集合中的所有文档

7.7 db.dropDatabase()

删除当前所在的数据库

7.8 db.studetns.drop()

删除数据库中的指定集合

8. 插入数据

插入一条文档

eg：db.student.insert({"name":"xiaoming"});

插入多条文档

eg: db.student.insert([{"name":"laowang"},{"name":"laozhang"}]);

# 我们不可能一条一条的insert。所以，我们希望用sublime在外部写好数据库的形式，然后导入数据库：

mongoimport --db test --collection restaurants --drop --file primer-dataset.json
--db test 想往哪个数据库里面导入
--collection restaurants 想往哪个集合中导入
--drop 把集合清空
--file primer-dataset.json 哪个文件

9. 查找数据

查找数据，用find。find中没有参数，那么将列出这个集合的所有文档：
db.restaurants.find()

精确匹配：
db.student.find({"score.shuxue":70});

多个条件：
db.student.find({"score.shuxue":70 , "age":12})

大于条件：
db.student.find({"score.yuwen":{$gt:50}});

或者。寻找所有年龄是9岁，或者11岁的学生
db.student.find({$or:[{"age":9},{"age":11}]});

查找完毕之后，打点调用sort，表示升降排序。
db.restaurants.find().sort( { "borough": 1, "address.zipcode": 1 } )

10. 修改数据

查找名字叫做小明的，把年龄更改为16岁：
db.student.update({"name":"小明"},{$set:{"age":16}});

查找数学成绩是70，把年龄更改为33岁：
db.student.update({"score.shuxue":70},{$set:{"age":33}});

更改所有匹配项目：
db.student.update({"sex":"男"},{$set:{"age":33}},{multi: true});

完整替换，不出现$set关键字了：
db.student.update({"name":"小明"},{"name":"大明","age":16});

10. 删除数据

只要匹配成功，就会删除
db.restaurants.remove( { "borough": "Manhattan" } )

删除一条
db.restaurants.remove( { "borough": "Queens" }, { justOne: true } )

DAY08 mongoVUE

MongoDb可视化操作工具 mongovue
---------------------------------------
1.1 安装步骤

1. 先安装Installer.msi原版程序

2. 将破解补丁里面的mongovue.exe 替换到安装目中的mongovue.exe搞定

1.2 使用步骤

1. 先点击那个加号创建连接

2. 填写正确的Name、server(127.0.0.1)、port(27017) 用户名密码不用填写，然后点击左下角，在点击底部当中的按钮

3. 在弹出的界面中点击左下角，ok，可视化出来了。

4. 具体操作步骤看文档

------------------------------------------
NodeJs 操作数据库

1. 引入mongodb模块

var mongoclient = require("mongodb").MongoClient;

2. 连接数据库

2.1 创建数据库的连接地址

var url = "mongodb://localhost:27017/数据库名";

2.2 连接数据库
mongoclient.connect(url,callback(err,db))

# db 代表当前的数据库对象

3. 插入数据

插入一条数据

db.collection("集合名").insertOne("json数据",callback(err,result));

插入多条数据

db.collection("集合名").insertMany([{},{},{}],callback(err,result));

4. 查找数据

db.collection("集合名").find("查新条件",cakkback(err,sursor))

# 当查询所有的数据的时候查询条件可以不写，或者写为{}

5. 修改数据

db.collection("集合名").update("修改谁","改动谁",callback(err,result));

6. 计算集合中文档中数量

db.collection("集合名").count().then(function(count))

7. 分页，从哪里开始查找数据

db.collection("集合名").find().skip(位置)

8. 限制选取的条数

db.collection("集合名").find().limit(长度);

# 更多crud操作请查看https://docs.mongodb.com/manual

DAY09 AJAX请求

Ajax请求
----------------------------------------
1.什么是ajax
   1.1 ajax即'asynchronous javascript and xml'(异步javascript 和 xml(xml一般为配置文件))
   1.2 传统的网页(不需要ajax)如果需要更新内容，必须重载整个页面
   1.3 ajax可以通过在浏览器后台与服务器进行少量数据交换，实现网页的异步更新（即可以在不重新加载整个网页的情况下，对网页的某个部分进行更新）

2.为什么要使用ajax
   1.在不刷新页面的情况下可以实现页面更新
   2.可以进行一步请求
   3.可以让客户端和服务端负载平衡
   ------------------

3.原生ajax请求(使用 XMLHttpRequest 对象)
   3.1 创建ajax核心对象
       if(window.XMLHttpRequest){
           var xhr = new XMLHttpRequest();
       }else{
           //兼容低版本ie
           var xhr = new ActiveXObject("Miscrosoft.XMLHTTP");
       }

   3.2 给ajax核心对象绑定一个监听http请求的事件
       3.2.1 判断http请求状态
           readyState : HTTP请求状态
0：初始化状态
1：初始化完成但是没有请求
2：请求已经发送但是没有收到响应
3: 收到了响应但是数据不完整
4：响应完成

       3.2.2 判断服务器返回状态
           state属性：
              200 响应成功
404 没有在服务器端找到这个页面
304 如果服务器没有修改该文件，则服务器不在发送请求

           xhr.onreadystatechange=function{
               if(xhr.readyState == 4){
                   if(xhr.status == 200){
                       //代表服务器成功响应
                   }else if(xhr.status == 404){
                       //代表没有找到页面
                   }
               }
           }

3.3 xhr.open(参数一，参数二，参数三); http请求参数初始化
参数一为请求方式参数二请求地址参数三为是否异步

3.4 发送http请求
xhr.send();

4 ajax请求传递参数
   4.1 ajax请求传递参数的时候是模拟表单进行请求的
   4.2 请求参数的形式为字符串键值对形式
   4.3 get请求参数是附加在请求的url后面的（url协议）
       GET方法中的信息无法保密和数据量太小
       因为GET方法提交的数据是作为URL请求的一部分进行数据提交

get请求和post请求
① get方式
把open方法的第一个参数设置为"GET"
把要传递的参数存放在第二个参数中以键值对和&连接起来
② post方式
设置open方法的第一个参数为"post"

传递参数分三种情况

1. 传递键值对的字符串时候，没有设置请求头

# 即请求头类型为text/plain

1. 参数采用可读流的形式拿到
2. 但是不能够以第三方模块body-parser拿到参数

2. 传递键值对字符串的时候，设置content-type为application/x-www-form-urlencoded

1. 参数采用可读流
2. 能够以第三方模块body-parser拿到参数

此时需要使用中间件 bodyParser.urlencoded({extended:false})

3. 传递json字符串的时候，设置content-type为application/json

1. 参数采用可读流

注意：
1.在进行ajax请求时候，传递参数的时候以字符串的形式传递过去，如果要传递对象，要先转换为json字符串。 JSON.stringify(obj); 同时设置请求头为application/json

2. application/json 和 application/x-www-form-urlencoded 的区别

前者可以传递的数据量比后者要大得多

5. json和普通数组对象在javascript 和 php 中如何相互转换

   普通字符串 json字符串和json对象三者的区别；
       1.普通字符串
           是使用单引号或双引号括起来的一串字符。
       2.json对象
           JSON对象，指的是符合JSON格式要求的JavaScript对象。
       3.json字符串
           就是在json对象外面加一对单引号字符串

   什么是json？
       json是用来处理数据的一种格式 xml也可以
       json大部分都是用来处理javascript和web服务器端之间的数据交换

   json对象结构
       对象结构
       数组结构
   在 javascript 中json字符串和普通对象数组如何转换
      JSON.stringify() 将普通对象或者json对象转换为json字符串
      JSON.parse() 将json字符串转换为json对象

DAY10 jquery ajax && 同源策略

jquery ajax
-------------------------------------
1. jquery load() 方法从服务器加载数据并把返回的数据放入被选的元素
   语法：$(selector).load(url,data,callback);
           url: 请求的地址
           data：发送请求的参数字符串键值对集合
           callback：load()方法加载完成后执行的回调函数
           callback 回到函数中可以设置不同的参数
               参数有callback(responseText,statusTXT,xhr)
                   responseText:成功调用时显示的结果
                   statusTXT：调用的状态返回success 或error
                   xhr ： XMLHttprequest 对象
2 $.get()方法
   语法：$.get(url,[data],[callbck],[type])
       url: 请求的url地址
       data：发送的请求参数
       callback：请求成功的回调函数
       type：返回内容的格式，格式有：xml、html、script、json、text、default

3 $.post()方法
   语法：$.post(url,[data],[callback],[type])
       url: 请求的url地址
       data：发送的请求参数
       callback：请求成功的回调函数
       type：返回内容的格式，格式有：xml、html、script、json、text、default

4 juery中采用 serialize() 将form表单参数序列化

5 $.getJSON(url,[data],[callback])
get请求返回json数据，若返回的不是json数据，那么不会成功返回json数据

6.$.ajax([settings]) 方法
settings里面的参数一般常用的有以下

1.url:
要求为String类型的参数，（默认为当前页地址）发送请求的地址。

2.type:
要求为String类型的参数，请求方式（post或get）默认为get。注意其他http请求方法，例如put和delete也可以使用，但仅部分浏览器支持。

3.timeout:
要求为Number类型的参数，设置请求超时时间（毫秒）。此设置将覆盖$.ajaxSetup()方法的全局设置。

4.async:
要求为Boolean类型的参数，默认设置为true，所有请求均为异步请求。如果需要发送同步请求，请将此选项设置为false。注意，同步请求将锁住浏览器，用户其他操作必须等待请求完成才可以执行。

5.cache:
要求为Boolean类型的参数，默认为true（当dataType为script时，默认为false），设置为false将不会从浏览器缓存中加载请求信息。

6.data:
要求为Object或String类型的参数，发送到服务器的数据。如果已经不是字符串，将自动转换为字符串格式。get请求中将附加在url后。防止这种自动转换，可以查看　　processData选项。对象必须为key/value格式，例如{foo1:"bar1",foo2:"bar2"}转换为&foo1=bar1&foo2=bar2。如果是数组，JQuery将自动为不同值对应同一个名称。例如{foo:["bar1","bar2"]}转换为&foo=bar1&foo=bar2。

   7.dataType:
   要求为String类型的参数，预期服务器返回的数据类型。如果不指定，JQuery将自动根据http包mime信息返回responseXML或responseText，并作为回调函数参数传递。可用的类型如下：
   xml：返回XML文档，可用JQuery处理。
   html：返回纯文本HTML信息；包含的script标签会在插入DOM时执行。
   script：返回纯文本JavaScript代码。不会自动缓存结果。除非设置了cache参数。注意在远程请求时（不在同一个域下），所有post请求都将转为get请求。
   json：返回JSON数据。
   jsonp：JSONP格式。使用JSONP形式调用函数时，例如myurl?callback=?，JQuery将自动替换后一个“?”为正确的函数名，以执行回调函数。
   text：返回纯文本字符串。

   8.beforeSend：
   要求为Function类型的参数，发送请求前可以修改XMLHttpRequest对象的函数，例如添加自定义HTTP头。在beforeSend中如果返回false可以取消本次ajax请求。XMLHttpRequest对象是惟一的参数。
   function(XMLHttpRequest){
   this; //调用本次ajax请求时传递的options参数
   }
   9.complete：
   要求为Function类型的参数，请求完成后调用的回调函数（请求成功或失败时均调用）。参数：XMLHttpRequest对象和一个描述成功请求类型的字符串。
   function(XMLHttpRequest, textStatus){
   this; //调用本次ajax请求时传递的options参数
   }

   10.success：要求为Function类型的参数，请求成功后调用的回调函数，有两个参数。
   (1)由服务器返回，并根据dataType参数进行处理后的数据。
   (2)描述状态的字符串。
   function(data, textStatus){
   //data可能是xmlDoc、jsonObj、html、text等等
   this; //调用本次ajax请求时传递的options参数
   }

   11.error:
   要求为Function类型的参数，请求失败时被调用的函数。该函数有3个参数，即XMLHttpRequest对象、错误信息、捕获的错误对象(可选)。ajax事件函数如下：
   function(XMLHttpRequest, textStatus, errorThrown){
   //通常情况下textStatus和errorThrown只有其中一个包含信息
   this; //调用本次ajax请求时传递的options参数
   }

12.contentType：
要求为String类型的参数，当发送信息至服务器时，内容编码类型默认为"application/x-www-form-urlencoded"。该默认值适合大多数应用场合。

   13.dataFilter：
   要求为Function类型的参数，给Ajax返回的原始数据进行预处理的函数。提供data和type两个参数。data是Ajax返回的原始数据，type是调用jQuery.ajax时提供的dataType参数。函数返回的值将由jQuery进一步处理。
   function(data, type){
   //返回处理后的数据
   return data;
   }

   14.dataFilter：
   要求为Function类型的参数，给Ajax返回的原始数据进行预处理的函数。提供data和type两个参数。data是Ajax返回的原始数据，type是调用jQuery.ajax时提供的dataType参数。函数返回的值将由jQuery进一步处理。
   function(data, type){
   //返回处理后的数据
   return data;
   }

15.global：
要求为Boolean类型的参数，默认为true。表示是否触发全局ajax事件。设置为false将不会触发全局ajax事件，ajaxStart或ajaxStop可用于控制各种ajax事件。

16.ifModified：
要求为Boolean类型的参数，默认为false。仅在服务器数据改变时获取新数据。服务器数据改变判断的依据是Last-Modified头信息。默认值是false，即忽略头信息。

17.jsonp：
要求为String类型的参数，在一个jsonp请求中重写回调函数的名字。该值用来替代在"callback=?"这种GET或POST请求中URL参数里的"callback"部分，例如{jsonp:'onJsonPLoad'}会导致将"onJsonPLoad=?"传给服务器。

18.username：
要求为String类型的参数，用于响应HTTP访问认证请求的用户名。

19.password：
要求为String类型的参数，用于响应HTTP访问认证请求的密码。

20.processData：
要求为Boolean类型的参数，默认为true。默认情况下，发送的数据将被转换为对象（从技术角度来讲并非字符串）以配合默认内容类型"application/x-www-form-urlencoded"。如果要发送DOM树信息或者其他不希望转换的信息，请设置为false。

21.scriptCharset：
要求为String类型的参数，只有当请求时dataType为"jsonp"或者"script"，并且type是GET时才会用于强制修改字符集(charset)。通常在本地和远程的内容编码不同时使用。

一般常用的参数有：
   url：发送ajax请求的地址
   data：发送到服务器的数据
   dataType：设置服务器返回的数据类型
       可用值有：xml、html、script、json、text、(jsonp)一般在跨域时候使用
   error：请求失败时候调用的回调函数
   success：请求成功时候调用的回调函数
   type：请求方式默认为get

-----------------------------------------------------------------
nodejs jsonp 处理

# 将一个函数调用的形式作为参数，返回给浏览器

express 处理

如果前端的回调函数名为callback

# 直接res.jsonp({});

# 如果前端返回的函数名不为calbback，如为aa

# 需要先指定函数名

eg: app.set("jsonp callback name","aa");

# 然后 res.jsonp()

========================================================

------------------------------------------------------------------------
同源策略
什么是同源策略

是浏览器的一个安全策略，现在基本上所有的浏览器都支持使用同源策略

源：协议、域名、端口三者的统称

       同源：即协议、域名、端口相同，当三者中有任何一个不相同，就不是同源
           即当我们打开一个网页的时候最开始有一个请求的源，如果我们在这个网页中点击一个按钮发送一个请求，
           那么浏览器会判断我们请求的这个网页的地址和我们的开始的源是否一致，如果一致就是同源浏览器就会执行这个脚本，如果不一致就是不同源，浏览器拒绝接收这个脚本。

同源和非同源实例
举例来说，http://www.example.com/dir/page.html这个网址，协议是http://，域名是www.example.com，端口是80（默认端口可以省略），它的同源情况如下。

           http://www.example.com/dir2/other.html：同源
           http://example.com/dir/other.html：不同源（域名不同）
           http://v2.www.example.com/dir/other.html：不同源（域名不同）
           http://www.example.com:81/dir/other.html：不同源（端口不同）

同源策略的目的
保证用户信息的安全，防止恶意的网站窃取数据。

   注意点：
       1.在进行同源策略测试的时候，一定要使用绝对路径，不要使用相对路径
       2.在发生了跨域请求的时候，浏览器会自动在请求头里面添加一个origin字段。此字段的意思为进行此次的请求来自于哪一个源
       3.在进行跨域请求成功之后，会在响应头里面添加一个Access-Control-Allow-Origin字段，告诉浏览器可以接受请求的源

-------------------------------------------------
如何解决跨域问题(即在非同源的情况下，也能请求成功)
   方法一：JSONP
       已知：src href都有跨域的能力
       jsonp模拟script标签
       它的基本思想是，网页通过添加一个script元素，从服务器请求数据，服务器收到请求后，将数据放在一个指定名字的函数里面传回来。服务器收到这个请求以后，会将数据放在回调函数的参数位置返回

注意：
由于<script>元素请求的脚本，直接作为代码运行。这时，只要浏览器定义了foo函数，该函数就会立即调用。作为参数的JSON数据被视为JavaScript对象，而不是字符串，因此避免了使用JSON.parse的步骤

   方法二：CORS
       CORS是跨源资源分享（Cross-Origin Resource Sharing）的缩写。它是W3C标准，是跨源AJAX请求的根本解决方法。相比JSONP只能发GET请求，CORS允许任何类型的请求。
       它允许浏览器向跨源服务器，发出XMLHttpRequest请求，从而克服了AJAX只能同源使用的限制。

CORS需要浏览器和服务器同时支持。目前，所有浏览器都支持该功能，IE浏览器不能低于IE10。

Jquery中的jsonp
$.ajax({

           url:url,
           data:data,
           type:"get",//如果使用jsonp跨域请求，不管设置的请求类型为什么最终都会是get类型请求
           dataType:"jsonp"
       })

在进行jquery的ajax的jsonp请求时候是模拟script标签进行请求,jquery会自动在请求的url后附加一个随机的的回调函数

       注意：
           1.修改jquery中的自定的的参数名和函数名的方法
               $.ajax({
                   jsonp:"aa",
                   jsonpCallback:"bb"
               })
           2.在进行jsonp跨域请求的时候，一定要使用函数将数据包裹进行输出，不然会报错

3.使用$.getJSON()需要手动添加函数名和参数名可以进行跨域请求

DAY11 mongoose

1. mongoose

1.1 是一个将JavaScript对象与数据库产生关系的一个框架，object related model。操作对象，就是操作数据库了

1.2 在用nodejs 操作数据库过程中没有一个语句是明显的操作数据库，感觉都在创建类、实例化类、调用类的方法。都在操作对象，
但是数据库同步操作了

1.3 mongoose的思想就是用操作对象的方法来操作数据库。

2 mongoose的基本使用方法

2.1 引入mongoose模块，不需要引入mongodb这个模块

# var mongoose = require("mongoose");

2.2 连接数据库

# mongoose.connect("mongodb://localhost:27017/xds");

# xds 表示数据库名字

2.3 创建模型可以简单理解为类，构造函数

# var user = mongoose.model("people",{"name":String})

# 第一个参数people 根据此参数来自动创建一个集合名peoples

# 第二个参数为文档的数据数据结构
2.4 实例化一个对象

# var user1 = new People({"name":"laownag"});

3. mongoose 提供两类方法来操做crud,curd为Create、Read、Update、Delete操作的总称

方法一：实例方法(只有两种)

save() 插入数据

创建实例后在进行插入

remove() 删除一条数据 # 要先找到数据在进行删除

方法二：静态模型方法

静态模型.create("文档对象",callback(err,实例文档对象))

注意：

1. Schema ：一种以文件形式存储的数据库模型骨架，不具备数据库的操作能力
2. Model ：由Schema发布生成的模型，具有抽象属性和行为的数据库操作对
3. createConnection() 创建多数据库进行连接

4. mongoose 提供了两个接口来给实例对象和静态模型添加方法来操作数据库

4.1 添加 mongoose 实例方法

eg: mongooseSchema.methods.findbyusername = function(username, callback) {
this.model('mongoose').find({username: username}, callback);
}

# this指实例对象
# mongoose 为对应的集合名称

4.2 添加 mongoose 静态方法，静态方法在Model层就能使用

eg: mongooseSchema.statics.findbytitle = function(title, callback) {
this.model('mongoose').find({title: title}, callback);
}

DAY12 略（实例：图书管理系统）

DAY13 聊天、图片上传

1. mongoose 模块其他部分

1.1 当使用createConnection 建立连接数据库时候，不能使用mongoose创建模型

# mongoose.model("集合名",schema结构); 不可以

# db.model("集合名",schema结构) 可以

# createConnection 适用于连接多个数据库，使用时候需要返回一个具体的数据库对象

2. web Socket和Socket.IO框架

2.1 HTTP无法轻松实现实时应用

# HTTP协议是无状态的，服务器只会响应来自客户端的请求，但是它与客户端之间不具备持续连接

# 我们可以非常轻松的捕获浏览器上发生的事件（比如用户点击了盒子），这个事件可以轻松产生与服务器的数据交互（比如Ajax）。但是，反过来却是不可能的：服务器端发生了一个事件，服务器无法将这个事件的信息实时主动通知它的客户端。只有在客户端查询服务器的当前状态的时候，所发生事件的信息才会从服务器传递到客户端。

2.2 但是可以通过一些方法来实现聊天室类似的功能

# 长轮询

客户端每隔很短的时间，都会对服务器发出请求，查看是否有新的消息，只要轮询速度足够快，例如1秒，就能给人造成交互是实时进行的印象。但是这种做法对服务器、客户端双方都造成了大量的性能浪费

# 连接

客户端只请求一次，但是服务器会将连接保持，不会结束请求（泪如没有写res.end()时，浏览器一直转小菊花）。服务器有了新数据，就将数据发回来，又有了新数据，就将数据发回来，而一直保持挂起状态。长连接这种做法的也造成了大量的性能浪费。

2.3 WebSocket协议能够让浏览器和服务器全双工实时通信，服务器也能主动通知客户端了。

2.3.1 WebSocket的原理

利用HTTP请求产生握手，HTTP头部中含有WebSocket协议的请求，所以握手之后，二者转用TCP协议进行交流（如QQ的协议）。现在的浏览器和服务器之间，就类似QQ和QQ服务器的关系了。

2.3.2 WebSocket协议的不足

需要浏览器支持，更需要服务器支持。

# 支持WebSocket协议的浏览器有：Chrome 4、火狐4、IE10、Safari5
# 支持WebSocket协议的服务器有：Node 0、Apach7.0.2、Nginx1.3

2.3.3 WebSocket服务器的搭建

从底层一步一步搭建一个Socket服务器很费劲，所以使用框架Socket.IO

# 官网 https://socket.io/

2.4 使用 socket.io

2.4.1 下载模块

npm install socket.io

2.4.2 创建服务器

var server = require("http").createServer(callback);

2.4.3 io对象的创建

var io = require("socket.io")(server);

4.4.4 socket对象创建完成后

在浏览器地址栏输入 http://127.0.0.1:3000/socket.io/socket.io.js 这是一个客户端的js文件的地址

4.4.5 创建index页面，这个页面中，必须引用/socket.io/socket.io.js文件。调用io函数，创建socket对象。

4.5.6 此时服务器端和客户端都有socket这个对象，name已经建立了socket连接通信

# 这个时候在浏览器的 network 面板中的type类型中会发现有一个websockt的类型

4.5.7
socket对象都有emit方法和on方法，emit方法用于发送一个自定义事件，on方法用于监听发送的自定义事件

# 只有在服务器的connection事件中才能践行事件的监听和发送

# 每一个用户连接进来都会有一个socket对象，由于我们的emit发送语句是由socket来进行的，所以每次发送发送给的是相对应的连接用户

# 在服务器端io.emit() 叫做广播，代表可以向所有的用户都发送广播

2.5 express结合socket.io使用

var express = require("express");
var app = express();
var http = require("http")(app);
var io = require("socket.io")(http)

app.listen(80)

-----------------------------------------------
3. 表单上传 formidable

文件上传只能采用post请求且需要在form表单中设置enctype="multipart/form-data";

4.图片处理

在nodejs中需要结合

http://www.graphicsmagick.org/ 这个需要安装在电脑中 nodejs要使用graphicsmagick，需要npm装一个gm的包

DAY14 爬虫与会话控制

1. nodejs 爬虫

1.1 需要用到的模块 cheerio

采用jquery操作来处理获取到的dom节点

1.2 对于HTML、XML 等 SGML 类语言的转义序列，可以采用 html-entities 模块来进行反转义

1.3
使用request模块进行请求网页
或者使用superagent

2. 会话控制

2.1 什么是会话控制
http协议：
是web服务器与客户端(浏览器)相互通信的协议，它是一种无状态协议。

http无状态：
指的是http请求是独立的，不持久的，不会维护http请求数据
简单地说，当你浏览了一个页面，然后转到同一个网站的另一个页面，服务器无法认识到，这是同一个浏览器在访问同一个网站。每一次的访问，都是没有任何关系的。

那么问题来了，比如我上一次访问，登陆了，下一次访问，又让我登陆，那岂不是很不爽

2.2 cookie

2.2.1 当访问一个页面的时候，服务器在与浏览器http进行通信过程中，命令浏览器存储一个字符串；浏览器再次访问相同域名的网页时候，浏览器会把上次存储的数据给取出来。

2.2.2 第一次访问一个服务器，不可能携带cookie。必须是浏览器在第一次请求中，携得到cookie信息，然后存储，此后每一次浏览器往这个服务器发出的请求，都会携带这个cookie。

2.3 cookie的特点

2.3.1 cookie是不加密的，用户可以自由看到；
2.3.2 用户可以删除cookie，或者禁用它
2.3.3 cookie可以被篡改
2.3.4 cookie可以用于攻击
2.3.5 cookie存储量很小未来可能被localStrorage替代

2.4 cookie的应用场景，做购物车，上一次的访问记录等

2.4 如何使用cookie？

2.2.1 在服务器中设置cookie， res负责设置cookie发送浏览器， req负责识别浏览器发送过来的cookie。

2.2.2 在express中使用cookie，需要借助第三方模块，cookie-parser

2.4 cookie的格式 (在浏览器中的格式)
Set-Cookie : name=value;[expires=date];[path=path];[domain=domainname];[secure];

name # 设置cookie的key
value # 设置cookie的值
expires # 设置cookie的过期时间
path # 设置cookie的有效范围
domain # 设置cookie的域，支持cookie跨域使用
sucre # 如果要求安全的cookie 必须要通过https协议来进行传输

示例：
Set-cookie:
id="laowang";expires=Monday,21-Oct-05 12:00:00 GMT;domain="aaa.com";path="/";secure;

2.5 在nodejs中设置cookie

res.cookie("key","value",{选项配置})

2.6 在nodejs中获取cookie

使用第三方模块 cookie-parser

使用方法：

# 引入模块 var cookieParser = require("cookie-parser");

# 设置路由中间件 app.use(cookieParser

# 获取cookie req.cookies

DAY15 COOKIE

1.nodejs中如何操作cookie

1.1 cookie的特点

# 服务器向客户端发送

# 浏览器将 cookie 保存

# 每次请求浏览器都会将 cookie 发向服务器

1.2 cookie的设置值

1.2.1 path：表示 cookie 影响到的路径，匹配该路径才发送这个 cookie。

1.2.2 expires 和 maxAge：告诉浏览器这个 cookie 什么时候过期，expires 是 UTC 格式时间，maxAge 是 cookie 多久后过期的相对时间。当不设置这两个选项时，过期时间为浏览器窗口的声明周期。

1.2.3 secure：当 secure 值为 true 时，cookie 在 HTTP 中是无效，在 HTTPS 中才有效。

1.2.4 httpOnly：是否允许浏览器js脚本操作cookie,true为不允许。

1.3 cookie的操作

使用express操作cookie需要用到第三方模块 cookie-parser

设置cookie形如以下
res.cookie('isVisit', 1, {maxAge: 60 * 1000});

1.4 浏览器操作cookie使用document.cookie

-------------------------
2.nodejs中的session操作

2.1 session的特点

# session是基于cookie的

# session数据一般存储在服务器的内存中

# 浏览器在第一次访问的时候，服务器会响应一个seesion_id在cookie中,
同时这个session_id对应相应的数据存储在服务器中，当你下次访问时，cookie 会带有session_id，然后服务器就知道你是上次访问过的某某某，然后从服务器的存储中取出上次记录在你身上的数据。

2.2 session 设置的参数

2.2.1 name: 设置 cookie 中，保存 session 的字段名称，默认为 connect.sid 。

2.2.2 store: session 的存储方式，默认存放在内存中，也可以使用 redis，mongodb 等。

2.2.3 secret: 通过设置的 secret 字符串，来计算 hash 值并放在 cookie 中，使产生的 signedCookie 防篡改。

2.2.4 cookie: 设置存放 session id 的 cookie 的相关选项，默认为
(default: { path: '/', httpOnly: true, secure: false, maxAge: null })

2.2.5 rolling: 每个请求都重新设置一个 cookie，默认为 false。

2.2.6 resave: 即使 session 没有被修改，也保存 session 值，默认为 true。

session的使用需要借助express-session中间件

转载于:https://my.oschina.net/u/3502345/blog/914597