node.js笔记

node.js安装：

1、nodejs的安装

​ 1.1 检测nodejs的版本 node -v (version:版本)

​ 1.2 path配置nodejs 的环境变量（当前版本都是自动安装配置环境变量）指令： path

​ 1.3 npm（node package mangment）node包管理工具

node之前版本是和npm分开的，两个模块是分别安装的，现在把npm打包到了node安装程序里面

2、什么是nodejs？

nodejs是javascript的运行环境，是一个执行js文件的平台。
nodejs存在类似于，其它的服务端语言，比如：java、php、python和C#等等。

javascript：是运行在浏览器端的基于对象、事件驱动机制的脚本语言。
nodejs：本身是一个平台是js的运行环境。

nodejs：要http、fs、path、url、querystring等模块。nodejs平台就是模仿os(操作系统)实现了各自的功能用来给服务器服务的。

3.node.js的特点：

1、事件驱动机制
2、单线程（异步操作 高效率的利用cpu资源）
3、非阻塞机制 

4、repl环境

repl：可交互式运行环境

repl环境的退出：
1、指令 ".exit"
2、ctrl+c ：双击

5、node指令运行js文件

常用的dos指令：
cls：清除屏幕
cd: 改变文件路径 （.. 退出到上一级文件夹）
dir：统计当前文件夹下文件的列表

node指令：编译执行.js文件

6、nodejs和javascript的区别

1、javascript是基于对象、事件驱动机制运行在浏览器端的脚本语言。
2、nodejs是一个平台，支撑javascript运行的一个环境。nodejs封装了不同模块，比如http、fs、path等模块。就是用来做一个服务端的功能。

7、http模块

http:超文本传输协议  
模块：nodejs平台实现的功能，抛出来给开发者使用。

http模块可以创建一个server服务器

1 http模块讲解
 
2 req，res详解

3 端口号作用
同一台服务器可以接收多个应用，只要是端口号不同，就可以访问不同的服务。（端口号的不同可以创建不同的服务和应用）
（1--1000）端口号都是给系统（win系统）服务的。
ftp：21  80端口 打印机用443端口
一般情况都是4位数字的端口号

4 req.url
默认情况下 取值“/”
如果主机名（localhost）和端口号后面有数据，那么req.url取值就是端口号后面的数据

5 res.write()
res:response
res.write();//(服务端向客户端发送数据)

 6 res.end()
 end():结束 服务端停止结束对客户端的响应。
 在结束之前还可以做最后的输出

fs文件系统：

fs文件系统模块

fs模块是nodejs的核心模块，主要功能就是用来读取，写入文件信息。

主要功能操作：它提供了文件的读取、写入、更名、删除、遍历目录、链接等POSIX文件系统操作。

// 文件的读取、写入等操作

/**
 * 文件异步读取
 * 引入文件系统fs：file system 
 * 功能：读取文件，写入文件数据，删除文件、打开文件等
 */
// require('模块名称') 1、nodejs的核心模块  
// 2、开发者自己写的js文件（一个文件就被称为模块）
 var fs = require('fs');

//  异步读取文件
/**
 * 1、要读取的文件路径
 * 2、读取文件时用到的字符编码
 * 3、回调函数 要来输出读取成功或失败的信息
 * readFile: read:读 file：文件
 */
fs.readFile('./studentMsg.txt','utf8',function(err,data){
    // 如果文件读取失败 就报err错误信息  data：读取文件成功的信息
    if(err){
        // 如果读取失败 就输出错误信息 message：消息
        console.log('读取文件失败：',err.message);
    }else {
        console.log(1111);
        // 如果读取文件成功 就把文本文件中的信息输出到控制台
        console.log(data);
    }
});
// 输出
console.log('2222');
add();
function add(){
    console.log(333);
}

// 同步读取文件
// 同步读取文件
// 引入文件模块
var fs = require('fs');

/**
 *  同步读取
 *  参数：1、文本文件（给他一个正确的路径）
 *        2、字符编码（utf8：全球所有的字符都收录）
 *  */
var data = "";
try {
    data = fs.readFileSync('./studentMsg.txt','utf8');
    console.log('data:',data);
} catch (err) {
    console.log("error:",err);
}
// 所有的程序语言中 都有try...catch 异常捕获机制
// try:试一试 试着做  catch：抓住 捕获
console.log(2222);

1.3、写入文件

// 异步写入文件
// 异步写入文件 
var fs = require('fs');

/**
 * writeFile:write（写）file（文件）
 * 参数 1、给定一个要写入的文件
 *      2、要写入的数据
 *      3、字符编码
 *      4、回调函数：返回文件写入失败或成功信息
 */
var msg = "1907A 披荆斩棘";
fs.writeFile('./teacherMsg.txt',msg,'utf8',function(err){
    if(err){
        console.log('写入文件失败：',err);
    }else {
        console.log(1111);
        console.log('写入文件成功');
    }
});

console.log(2222);

1.4、同步和异步的区别

同步：执行一个方法，只有方法给出结果后，才算结束
异步：执行一个方法，只是交代要做的事情，然后去做其它事情，而交代的事件在回调中处理。

1.5、同步追加文件

// 同步追加文件内容

var fs = require('fs');
console.log(111);
try {
    fs.appendFileSync('./classInfo.txt','今天的你感谢曾经奋斗的你','utf8');
    console.log(222);
} catch (error) {
    console.log(error);
}
console.log(333);

1.6、异步追加文件内容

// 向文件中追加内容 是不清楚原有数据的情况下  进行的

// 写入数据 每次都要把原来的数据清除掉 
var fs = require('fs');

/* fs.writeFile('./classInfo.txt','1907A班','utf8',function(err,data){
    if(err){
        console.log('写入数据失败');
    }else {
        console.log('写入数据成功',data);
    }
}); */
console.log(111);
fs.appendFile('./classInfo.txt','新追加的内容','utf8',function(err){
    console.log(2222);
    if(!err){
        console.log('追加文件内容成功');
    }
});
console.log(3333);

2.1、nodejs服务器请求文件：案例步骤

1、使用nodejs创建一个http的服务器
2、引入fs文件系统模块
3、根据浏览器中的url地址不同来读取对应的文件
	路径："/"，读取index.html
	     "/list.html",读取list.html
	     "/css",读取style.css文件
4、将读取的文件信息输出到浏览端	     

//  引入http模块
var http = require('http');
var fs = require('fs');

http.createServer(function(req,res){
    var url = req.url;
    // 设置头信息，读取不同文件
    res.writeHead(200,{"Content-Type":"text/html/css;charset=utf8"});
    if(url == '/') { // "/"，读取index.html
    // 回调的是 错误和成功的信息和数据
        fs.readFile('./index.html','utf8',function(err,data){
            if(err){
                res.write('读取index.html文件失败');
                res.end();
            }else {
                res.write(data);
                res.end();
            }
        });
    } else if(url == "/list.html"){ // "/list.html",读取list.html
        fs.readFile('./list.html','utf8',function(err,data){
            if(err){
                res.write('读取list.html文件失败');
                res.end();
            }else {
                res.write(data);
                res.end();
            }
        });
    } else if(url == "/css"){
        fs.readFile('./style.css','utf8',function(err,data){
            if(err){
                res.write('读取css文件失败');
                res.end();
            }else {
                res.write(data);
                res.end();
            }
        });
    }

}).listen(3000,function(){
    console.log('server success!');
});

3、favicon.ico文件是网站图标

supervisor 后面加 node.js 文件 他会自动启动服务，不用在手动重启服务了

模块与npm包管理工具：

1、核心模块与文件模块

nodejs是一个js运行环境，是一个平台。nodejs基于操作系统，封装了一些功能，http、tcp、udp，i/o模块、path、fs、stream等等。
以上这些通过nodejs内置的模块，它们就称为核心模块。http、fs、path等

文件模块：只要咱们写一个js文件，每一个文件都是模块。
注：核心模块是nodejs内置的一些功能模块，文件模块是开发人员编写的js文件

2、从模块外部访问模块内部的成员

在nodejs中，一个文件又被称为一个模块。从一个模块访问外部模块中变量或方法
先创建了两个模块，demo1，demo2
在demo1中声明的变量str，方法add（）
在demo2中没有权限访问，如果要访问到的话，就要把变量或方法做成全局属性
用到global来把str和add函数变成全局属性
global.str = "声明变量";
global.add = function(){console.log('函数表达式');}
在demo2中就可以访问到str和add（）.

2.1、使用exports对象

// exports 这个对象的属性 是可以将模块内的方法、变量等抛出，并且在其它引入的模块中可见（可使用）
// demo1.js
exports.str = "hello";
exports.hello = function(){
    console.log('你好世界');
}

// 在demo2.js中引入demo1.js文件 可以使用demo1中的变量和方法
var demo1 = require('./demo1');
demo1.hello();
demo1.str; // 这里是str变量的调用 需要console.log才能看到

2.2、将模块定义为类

// class是在ECMAScript2015版本之后加入的概念 es6
// class 关键字：确定一个类型 Student以类概念的存在
class Student {
    // 构造函数 默认存在一个无参的构造函数
    constructor(n,a){ 
        this.name = n;
        this.age = a;
    }
    // 函数表达式
    add = function(){
        console.log('add');
    }
}

module.exports = Student;

2.3、将模块定义为类变量和类函数

// 返回一个JSON Object
var app = {
	name: 'app',
	version: '1.0.0',
	sayName: function(name){
		console.log(this.name);
	}
}
module.exports = app;
// 调用模块
var app = require('./app.js');
app.sayName('hello');//hello

// 定义变量

// 定义函数
var func1 = function() {
   console.log("func1");
};
 
var func2 = function() {
   console.log("func2");
};
  
exports.function1 = func1;
exports.function2 = func2;
// 函数调用
var functions = require("./functions");
functions.function1();
functions.function2();

3、模块对象的属性

什么是模块对象？
模块：核心模块（nodejs内置），第三方模块（第三方组织发布的），自定义模块（开发人员）
在nodejs平台上，每一个文件就可以称为一个模块。
定义了一个modules它在模块内就是一个模块对象。每一个模块内斗内置了一个对象就是module（模块）
每个模块对象都代表当前模块。使用module.exports时才能把整个的模块文件作为一个对象抛出。
模块对象的属性：exports就是module.exports 定义的属性。

注：module.exports 和exports的区别

1. module.exports 初始值为一个空对象 {}
2. exports 是指向的 module.exports 的引用
3. require() 返回的是 module.exports 而不是 exports

4、npm包管理工具

什么是npm？
node package management:node包管理工具 （主要管理模块）
模块：核心模块、文件模块
文件模块：自定义模块、 第三方模块
npm 就是用来管理和安装第三方模块的

npm命令详解
1、npm -v // v:version(版本)
	npm -v 查看当前npm的版本号
2、安装模块
命令： npm install model name (模块名称)
比如：安装jquery模块
	npm install jquery
查看 npm中模块的清单命令
	npm list 这个命令会列出所有安装的第三方模块
	
3、卸载模块 uninstall:卸载
命令： npm uninstall modelname (模块名称)
卸载jquery模块  
	 npm uninstall jquery
	 
4、npm清单指令
	npm list  把当前安装的所有第三方模块列出
	
5、查看给定模块的信息
指令：npm info modelName(模块名称)
比如：查看jquery的信息 
	npm info jquery
	
6、指定模块版本号安装
指令： npm install modelName@版本号
比如： npm install jquery@1.12.1

5、npm发布流程

1、注册npm账号
2、登录npm账号
3、创建工程项目包 npm init 包名称 -y
4、发布程序包到npm
5、执行命令 npm publish

6、安装淘宝镜像

npm 中的淘宝镜像 cnpm C:中国china
镜像：把国外一些数据放到国内服务器上。
cnpm就是把npm平台上的模块等功能文件，都放到淘宝的服务器上。国内用户在访问的时候就方便了。
npm install 模块，
cnpm把npm的功能都复制了一遍，npm的指令在cnpm上都可以使用。
注：使用 设置淘宝镜像地址

安装cnpm
通过npm指令安装： npm install cnpm -g --registry=https://registry.npm.taobao.org;

package.json文件

package.json文件作用
1、用来描述工程项目的信息
2、描述第三方模块之间的依赖

注：1、通过npm init指令来创建package.json  
	2、快速创建package.json文件的指令 npm init -y
	3、给package.json文件增加模块依赖的指令
		npm install 模块名称 --save（将模块增加到当前package.json）

7、组织与管理模块

var http = require('http');
// 管理模块 ： 第三方模块 比如jquery s-date这样的开源模块
var jq = require('jquery');
var date = require('s-date');

// 三种方式可以加载 
// 1、从node-modules文件夹下面加载
// 2、从package.json文件的目录中加载
// 3、从全局目录中加载（node配置的环境变量）
// 注：建议把所有的第三方模块，都安装到本地文件夹的node-modules里面

7.1、从node-modules目录中加载模块

如果传递给 require() 的模块标识符不是一个核心模块，也没有以 '/' 、 '../' 或 './' 开头，则 Node.js 会从当前模块的父目录开始，尝试从它的 /node_modules 目录里加载模块。
如果还是没有找到，则移动到再上一层父目录，直到文件系统的根目录。

例子，如果在 '/home/ry/projects/foo.js' 文件里调用了 require('bar.js')，则 Node.js 会按以下顺序查找：
    /home/ry/projects/node_modules/bar.js
    /home/ry/node_modules/bar.js
    /home/node_modules/bar.js
    /node_modules/bar.js

这使得程序本地化它们的依赖，避免它们产生冲突。

7.2、使用目录加载模块

可以把程序和库放到一个单独的目录，然后提供一个单一的入口来指向它。 把目录递给 require() 作为一个参数，有三种方式。

第一种方式是在根目录下创建一个 package.json 文件，并指定一个 main 模块。 例子， package.json 文件类似：

{ "name" : "some-library",
  "main" : "./lib/some-library.js" }

7.3、从全局目录中加载模块

如果 NODE_PATH 环境变量被设为一个以冒号分割的绝对路径列表，则当在其他地方找不到模块时 Node.js 会搜索这些路径。

在 Windows 系统中， NODE_PATH 是以分号（;）间隔的。
强烈建议将所有的依赖放在本地的 node_modules 目录。 这样将会更快地加载，且更可靠。

express框架使用：

1、express的安装

1、什么是express？
express是基于nodejs平台，快速开发的web框架。
2、安装指令
	a)新建一个文件件myapp，进入myapp
	b)通过npm init指令生成package.json文件
	c)新建index.js文件为main（入口文件）
	d)在当前目录myapp下安装express 模块。
		注： npm install express --save  // 可用于开发环境
			npm install express --savedev // 可用于线上环境
			
3、express服务的启动
	3.1）引入express模块
	3.2） 根据express的模块对象生成一个应用对象 var app = express();
	3.3) 给app应用绑定路由、绑定端口
		app.get('/',function(req,res){}); // 绑定路由
		app.listen(3000); // 绑定端口
			

2、express的路由

1、什么是路由？
	由url地址和一个请求类型（get、post）来组成，根据组合的数据执行相应的业务逻辑。
	

3、express托管静态资源文件

express中有一个express.use('static','/public')
// 静态资源：最早的网页都是静态网页，内容不可以更新，都是写死的数据。
暂时不会改变的都会称为静态资源， 比如公用css文件，js工具类，图片等。

1.1、Express简单介绍

​ Express是一个基于nodejs平台，极简、快速开发的web框架。（web通过浏览器允许的项目页面都称为web工程）

1.2、Express特点

​ 2.1生成了一系列的功能模块提供调用，省去了重复开发的时间

​ 2.2 代码健壮、开发体验友好，使api的开发快速简单

​ 2.3 Express只是对未有的功能做了扩展，nodejs原有的功能不做改变

1.3、Express官网

2、Express的安装和使用

2.1 Express的安装

安装指令： npm install express --save

2.2 Express的使用 搭建服务器

// 1、引入Express的模块 
	var express = require('express');

// 2、根据express模块生成一个应用对象
var app = new express();

// 绑定路由
app.get('/',function(req,res){res.send('根目录');});

// 3、绑定端口 
app.listen(3333,funciton(){
	console.log('express server 启动成功！');           
});

3.1 路由的介绍，Express框架的路由

1、什么是路由？
	路由是一个url地址和一个get或post等请求参数组成的节点，在这个节点可以处理相应的业务逻辑。
	
2、什么是url？
url：统一资源定位符（）
3、前后端路由的区别？
	前端路由：也就是说前端页面的跳转根据前端的业务逻辑来处理。
	后端路由：是根据客户端把数据提交到服务端后，根据服务端（后端）业务处理后进行页面的跳转
注：前端路由是在前端的业务逻辑中处理，后端路由在服务端的

4、静态资源服务器

静态资源文件托管 还是用到的Express框架提供的static()方法。把特定的目录（文件夹）托管，以一个别名的形式托管到express服务器上。被托管的文件夹中的所有文件，都可以在服务器地址中访问到。

https://www.jinshu.com/p/ea0122ad1ac0 body-parser模块

5.1、body-parser模块的介绍

body-parser是一个HTTP请求体解析中间件，使用这个模块可以解析JSON、Raw、文本、URL-encoded格式的请求体，Express框架中就是使用这个模块做为请求体解析中间件。

注：post提交的数据，都是通过http中body（消息体）传输数据的。对于post提交请求会用到req.body取值。

模块在代码中的使用和配置

// 将body-parser模块引入到文件中
var bodyParser = require('body-parser');

// 设置一个参数，可以解析body体的数据
比如是express框架中的应用。
app = express();
app.use(bodyParser.urlencoded({"extend":false}));

// 配置页面路由 post类型
app.post('/',funciton(req,res){
         var info = req.body;
         });

5.2、body-parser模块的安装

npm install body-parser --save

5.3、使用req.body解析post提交的请求

两种方式可以解析post提交的请求体中的消息

5.3.1、利用body-parser模块

var bodyParser = require('body-parser');
// 在应用对象中设置bodyparser配置信息
app.use(bodyParser.urlencoded({extended:false}))

5.3.2、利用querystring模块

var qs = require('querystring');
// 配置路由信息 
app.post('/',function(req,res){
    var str = "";
    // 先遍历取到post提交的消息体中的数据
    req.on("data",function(d){
        str += d;
    });
    // 事件结束后 进行解析
    req.on("end",function(){
        // 将消息体中的数据取出
        var info = qs.parse(str);
    });
});

全局模块的介绍

1.1 全局模块

javascript：编程语言，js编译和执行是在浏览器内核。
window：js中的一个全局对象。 都是在浏览器中编译执行的，js文件都是在html页面运行的

nodejs:运行js语言的平台，浏览器（chrome的v8引擎）。
global：nodejs中的一个全局模块。
在nodejs中，一个文件可以被称为一个模块。而模块内的作用域对外是不可用的。global
a.js和b.js文件，这两个文件里面的属性和方法，怎么能互相访问？就是把一个模块内的属性和方法，变成全局的作用域。这个时候就用到了全局模块global。
注：nodejs中的js文件和javascript的js文件，运行的宿主（所依赖的对象）环境不一致。使用的场景也不同。

1.2、全局对象和全局变量

nodejs中的全局对象是global，全局变量有如下：__dirname,__filename

// __filename:表示的是当前文件所在的绝对路径和文件名称
console.log(__filename);
// __filename:作为一个全局变量，在nodejs工程内可以随意调用。用到某个文件隶属于那个文件夹，某个文件本身的路径是什么？


// __dirname:表示的是当前文件所在的文件夹，只给出文件夹的绝对路径，不给出文件的名称
console.log(__dirname); // 当前文件的绝对路径

__dirname全局变量使用的小场景

var fs = require('fs');

// 给用户信息文本文件一个绝对路径
var fileUrl = __dirname + "/userinfo.txt";
console.log(fileUrl);
// 文本文件的绝对路径
fs.readFile(fileUrl,'utf8',function(err,data){
    if(err){
        console.log('文件读取失败');
    }else {
        console.log('读取成功：',data);
    }
});

__filename:取到文件名称（以绝对路径展示）

__dirname:取到目录（路径）名称（以绝对路径展示）dir：direction路径

全局方法

setTimeout();clearTimeout();
一个定时器的使用场景比较常见，系统平台就把它们做成全局的方法，在系统内使用
setTimeout(fun,1000); 参数1 fun:匿名函数  参数2 时间值，以毫秒数计
setInterval();clearInterval();
注：setTimeout()类似于一个定时炸弹，只在给点的时间值触发一次;
	setInterval()在给定的时间间隔内，重复执行。

1.3 nodejs中控制台的方法

console:输出到控制台，打印到控制台
log:日志 
info：信息
error：错误
warn：警告
dir：路径

2、path模块，path：道路，小路

path模块：功能就是处理一切和路径有关的方法

3.pqth常用方法

1、path.parse()  是把字符串转换成对象
var str = '/home/resource/imagese/xiaomi.jpg';
var result = path.parse(str);
// 对象中的属性值
/**
 * 1、root：根目录
 * 2、dir：路径（当前文件所在的绝对路径）
 * 3、base：文件的名称 xiaomi.jpg
 * 4、ext:文件的后缀类型
 * 5、name:文件的名称，不带文件后缀
 */

2、path.join();用来链接路径
var dir = path.join(__dirname,'/user.json');
console.log(dir); // 文件的绝对路径+“/user.json”
var dir2 = path.join('/file/jpg','/dirs/css');
console.log('dir2:',dir2); // file\jpg\dirs\css

3、path.normalize(): 规范化路径
var str = '/file//css/js'; 
// 严格按照正确的格式
var res = path.normalize(str);
console.log(res);

4、path.resolve()
// 4、path.resolve()
// from... to 两个参数，把这个两个参数拼接一个完整的绝对路径
var r1 = path.resolve('/foo/baz','./css');
console.log(r1);
var r2 = path.resolve('/foo/baz','/css');
console.log(r2);
var r3 = path.resolve('/foo/baz','../css/json');
console.log(r3);

express生成的概念：

安装指令： npm install express-generator -l;

局部安装仅限于安装的当前工程项目

7.3.1 Express应用生成器创建项目指令

指令：express 工程名称

启动指令： npm start

   change directory: 改变路径 进入工程myapp
     > cd myapp

   install dependencies: 安装模块之间的依赖
     > npm install 

   run the app: 启动项目
     > SET DEBUG=myapp:* & npm start

​ express生成文件加的作用：

bin：存放启动项目的脚本文件
node-modules:存放工程项目中安装的模块依赖
public：静态资源文件（js、css、html和图片等）
routes:路由文件
views：视图文件，存放的是项目中配置的视图模板文件
package.json：工程项目的信息及模块依赖信息
app.js：应用核心配置文件

mongodb 数据库的安装：

1、mongodb数据库的安装

2、什么是mongodb数据库？

数据库：存储数据的仓库。

mongodb：是非关系型数据库，相对于之前的关系型数据库来说，比如：oracle、mysql和ms sql server等。

3、启动mongodb的命令

服务端启动：mongod --dbpath d:/mongodb

客户端：mongo localhost:27017
       mongo 127.0.0.1:27017
       
注：27017端口是mongodb数据库占用的端口。 
打开本地mongodb数据库的指令

4、常用的mongodb数据库操作指令

1、显示mongodb中的数据库名称
指令：show dbs
注： show：显示  dbs:database:数据库 
2、创建数据库
指令： use 库名称
创建一个名称为 zz7a的数据库  
例子： use zz7a;

比如使用指令“use student” 来创建student数据库，此时student数据库创建成功，在未插入数据之前，真实的数据库时不存在的。
只有给student数据库插入一条数据，这个student数据库才会创建成功。

3、查询数据的指令
db.student.find();
db:数据库  student：数据库名  find：方法 查找

4、创建数据库中的表
 4.1) 先选中所在的数据库
 4.2）在选中的数据库下创建表（存放数据记录的）
 指令：db.createCollections("表名称")
 
 案例：演示
 1、新建一个student数据库，里面新建一个叫stu1的表。
 use student // 创建数据库 就已经切换到当前数据库
 2、创建stu1的表指令
 db.createCollection('stu1'); // 创建stu1表
 
 查询数据库 show dbs
 查询表  show collections  
注：非关系型数据库，都把表称为集合（collections），之前老的数据库（关系型数据库）都称为表。
 
 5、删除指令
 
5.1、删除表（集合collections）
指令：db.collections名称.drop();//选中当前表执行drop（）方法
5.2、删除数据库
指令：db.dropDatabase();
注：选中当前数据库，然后执行上面指令

 

mongodb：增删改查，

1、mongoose是什么以及作用

​ mongoose是中间件或是一个操作mongodb数据库的模块。

中间件： 中间件是一种控制函数，类似插件，能控制流程中的init、validate、save、remove`方法

mongodb:非关系型数据库

mongoose：操作mongodb数据库的模块或中间件函数

作用：操作mongodb数据库，对数据库进行增删查改。

1.1、mongoose的安装

通过npm指令：npm install mongoose --save
生成一个工程项目之后，在工程项目的文件夹下执行安装指令，给工程项目增加需要模块依赖。

1.2、mongoose链接数据库

var mongoose = require('mongoose'); // 引入mongoose中间件
// 在mongoose的模块中有一个connect()方法用来链接数据库
mongoose.connect('mongo://localhost:27017/数据库名称',function(){}); // 参数1；本机或服务器上mongodb的安装路径
// 端口号是固定的27017

1.mongoose 是什么：
   mongodb ：数据库，对 mongodb 进行了一点操作，数据库的增删该查，
   在代码中嵌入的原声的指令过于麻烦，不人性话，所以退出了mongoose 
   mongoose：只中件插件，还可以引入代码中的功能快，就像是 引入          expressmok一样，
2.mongoose 作用：用来处理mongoodb数据库的数据进行增删该查。
3.mongoose 安装指令是：
     cnpm  i mongoose --save
4.   npm    小黑框指令：
     express   (文件名字)       作用：    自动生成文文件夹
     express -e  (文件名字)     作用：  视图文件不一样，老版本的
     cnpm i                    作用：    生成 项目依赖
     npm  init                 作用： 生成package。json文件
     npm init -y               作用：  快速生成
     cd   ../                  作用：   返回上一层
     cls                       作用：   清屏
     cnpm i mongoose --save    作用：   安装 mongoodb 数据库
     npm start                 作用：   启动
     npm i express --save      作用:package-lock json 生成
     npm  i   bootstrap@3      作用： 在命令提示框下载 bootstrap
 
 5.  schema:
    关系型数据库：表都是先创建结构，然后给结构创建表，有了表结构之后在插入数据。
    mongodb ：非关系数据库，先定义一个表结构，这个表结构就落在schema 上面。
    
  schema:   是定义了一个集合，（表）骨架，（表结构，要存储的数据库的哪点）
 4. mongodb 的数据类型：
 
 
     定义schema ,就是给一个集合表定义结是吗，用到不通的属性名称。
     这点属性名称都有自己的数据类型。
     比如定义一个用户的schema（姓名，年龄，性别，出生日期），对应的数据类型就是：
     姓名：    string(字符串)
     年龄：     number（数字）
     性别：     string()
     出生日期：     data
5.  model：
   通过定义好的schema 来生成model，model就被称为模板，因为schema定义好了结构有了这点数据结构而生成了

2、schema、model和entity三者之间的关系

    Schema  ：  一种以文件形式存储的数据库模型骨架，不具备数据库的操作能力

    Model   ：  由Schema发布生成的模型，具有抽象属性和行为的数据库操作对

    Entity  ：  由Model创建的实体，他的操作也会影响数据库

3、mongodb的数据类型

mongodb的数据类型：是创建schema骨架时，对定义集合的字段属性做的定义。

var course = new Schema({
    日期："date",
    课程名称： "String",
    timestamp: new date()
});
// timestamp:时间戳

4、mongoose的增删查改

4、1 增加（给集合（表）增加一条记录）

mongose中间件的使用：

1.1、mongoose是什么。作用？

​ mongodb：数据库，对mongodb进行了一些操作，数据的增删查改。

在代码中嵌入的原生指令过于繁琐，不人性化。所以推出了mongoos

mongoose：指“中间件”，还可以是引入到代码中的“功能模块”，就像引入expressmok一样。

mongoose的作用：就是用来操作mongodb数据库，进行数据的增删查改等操作。

2、mongoose模块的安装

指令： npm install mongoose --save

注：–save 安装到当前项目中

3、schema：

关系型数据库：表 都是先创建表结构，然后给表结构创建表。有了表之后再插入数据。

mongodb：非关系数据库。 先定义一个表结构，这个表结构就落在schema上面。

–	–	–
姓名	年龄	性别

schema：是定义一个集合（表）的一个骨架（表结构，要存储的数据有哪些）。

4.mongodb的数据类型 :集合中字段的数据类型（表字段的数据类型）

定义schema，就是给一个集合（表）定义结构是，用到不同的属性名称。

这些属性名称都有自己的数据类型。

比如定义一个用户的schema（姓名、年龄、性别、出生日期），它们对应的数据类型就是

姓名：String（字符串）

年龄：Number（数值类型）

性别：String：（Boolean（true，false）（char））

出生日期：Date（2019.12.25）

5、model

通过定义好的schema来生成model，model就被称为模板。因为schema定义好了结构

有了这些数据结构而生成的model，就代表了一个模型。

6、实体entity

通过model创建就是一个实体entity。通过entity或modle就可以操作mongodb的数据库。

booststrap的使用：

1、什么是bootstrap？

bootstrap是一个前端ui（用户接口）开发框架，是web开发变得快速，简单、便捷。

简单、直观、强悍的前端开发框架，让web开发更迅速、简单。

2、bootstrap的使用

引入bootstrap的使用文件
1、下载bootstrap的文件
	在bootstrap官方文档下载，将js、css和fonts等文件夹放到新建的工程项目内。
2、去bootstrap官方网站下载模板页面
	在这个模板中会将应用到的三个文件先引入，分别是bootstrap的css和jquery和bootstrap的js文件

3、引入文件的文件结构
	css：bootstrap.css和bootstrap.theme.css(theme:主题)
	js: bootstrap.js和bootstrap.min.js
	fonts：字体类库
	

3、bootstrap的html模板

<!DOCTYPE html>
<html>
   <head>
      <title>Bootstrap 模板</title>
      <meta name="viewport" content="width=device-width, initial-scale=1.0">
      <!-- 引入 Bootstrap -->
      <link href="./bootstrap/css/bootstrap.min.css" rel="stylesheet">
   </head>
   <body>
      <h1>Hello, world!</h1>
       <!-- jQuery (Bootstrap 的 JavaScript 插件需要引入 jQuery) -->
      <script src="./bootstrap/js/jquery.js"></script>
      <!-- 包括所有已编译的插件 -->
      <script src="./bootstrap/js/bootstrap.min.js"></script>
   </body>
</html>

bootstrap的html模板文件的使用

1、bootstrap提供了css和js文件，使用时只管引入提供的文件就可以了。

2、引入bootstrap.js前一定要先移入jquery.js，因为bootstrap的js是依赖jquery.js类库开发的

4、bootstrap的网格系统

不仅是boostrap的ui框架，其它框架也是使用网格系统。有利于开发者进行页面布局

基本的网格布局

<div class="container">
   <div class="row">
      <div class="col-*-*"></div>
      <div class="col-*-*"></div>      
   </div>
   <div class="row">...</div>
</div>
<div class="container">....

5、form表单的使用

1、使用form表单时，一定要给form表单增加一个 role='form'
2、把使用到的标签，都放到以form-group命名的class下

6、按钮的使用

1、按钮风格样式
	default：默认（btn-default）success:成功，info：信息，warning：警告，danger：危险
2、按钮的大小
	lg:大的 sm：小的 xs：超小的 （btn-lg）

7、栅格布局（网格布局）

栅格，从栅栏中引申的，栅栏就是咱们国内“篱笆”。用几块木板把家里院子围起来。
1、首先把页面分成12列，每一列为最小单位。布局时就可以结合实际元素占用页面的大小来分配
	页面的布局根据元素的大小来使用网格

8、辅助类

bootstrap的使用场景

使用场景：主要是为了后台管理系统服务的，oa：办公管理系统，cms:
	腾讯视频前端（页面多而且风格样式不统一，每天会产生不同的新页面）
	腾讯视频后端（管理系统：超级管理员、管理员、普通用户）页面风格统一的，bootstrap的ui框架。
	电力行业、电信行业、公安、法院、企业网，企业网的后台管理，医院院管系统
	bootstrap来布局页面，剩下的功能代码都在js、java中完成

字体、导航、面板

对于后台管理系统来说，页面的风格样式都是固定的。

分页

分页组件是有bootstrap的新插件生成的，要把新的插件引入，不仅仅是bootstrap基本模板中配置的那些。
分页在bootstrap有一个专门的插件bootstrap-paginator.js

1、在html页面中 增加一个分页的元素节点，基于这个节点调用bootstrap插件给定的分页方法（函数）进行分页。
2、插件函数中的配置项，需要根据服务端的数据进行填充
3、点击分页插件上的按钮，插件自带的回调函数来处理当前的业务数据

模态框

1、什么是模态框？
能覆盖父窗体的弹出框就叫模态框。（不是全部的覆盖，只是在父窗体上增加了一层遮罩）
2、模态框的用法
根据设置的dom元素节点，在点击事件时，对要弹出的窗体设置属性，
data-toggle, data-target 模态框就自动弹出

data-toggle="modal"  // 模态框的固定设置
data-target="#myModal" // target对应的是模态框的id

boostrap网络链接：

 <link rel="stylesheet" href="https://cdn.staticfile.org/twitter-bootstrap/4.3.1/css/bootstrap.min.css">
 <script src="https://cdn.staticfile.org/jquery/3.2.1/jquery.min.js"></script>
 <script src="https://cdn.staticfile.org/popper.js/1.15.0/umd/popper.min.js"></script>
 <script src="https://cdn.staticfile.org/twitter-bootstrap/4.3.1/js/bootstrap.min.js"></script>

留言板 项目：详解：

留言板

1、express生成器生成工程项目

1.1、express的指令新建工程
	express bbs
	新建工程后的三个步骤：
	1、进入工程项目cd bbs;
	2、安装工程模块依赖；npm install 
		npm install mongoose --save
	3、启动服务 npm start
1.2、安装mongoose模块
	npm install mongoose --save

2、新建页面

​ 2.1、页面：有留言标题+留言内容（bootstrap页面优化）

3、配置mongodb数据库链接

​ 3.1、链接数据库

// 链接数据库
mongoose.connect("mongodb://localhost:27017/bbs",function(err){
    if(!err){
        console.log('mongodb数据库链接成功！');
    }
});

​ 3.2、生成schema、model

// 应用mongoose对象的Schema
var Schema = mongoose.Schema;
// 基于mongoose的schema来创建一个表结构（骨架）
var bbsSchema = new Schema({
    bbsTitle: String,
    bbsContent: String
});
// model通过schema来创建的 （model可以操作数据库）
var bbsModel = mongoose.model('bbsCon',bbsSchema);

// 把bbsModel作为一个模块对象抛出
module.exports = bbsModel;

​ 3.3、使用mongoose来操作（crud：增删查改）

/* 发表留言 */
router.post('/add', function(req, res, next) {
  // post提交的数据都是通过 req.body来解析
  var title = req.body.bbsTitle;
  var content = req.body.bbsContent;

  // 通过实体entity来save数据 
  var bbs = new bbsModel({
    bbsTitle: title,
    bbsContent: content
  });
  // 保存到mongodb数据库 是mongoose下的save方法
  bbs.save(function(err,data){
    if(err){
      res.send('保存留言信息失败');
    }else {
      // 数据保存成功后跳转页面（重新刷新页面，把数据库中数据取出来）
      res.redirect('/bbs.html');
    }
  });
});

// 查询

// 查询数据库中的数据 get 请求（）
router.get('/find',function(req,res){
  // req:request是浏览器对服务端的一个请求
  // res:response是服务端对浏览器的一个回应

  // model是对mongodb数据库进行操作（增删查改）
  bbsModel.find({},function(err,data){
    // err:查询数据库失败
    // data：查询数据库成功后，返回的查询数据
    if(err){
      res.send('查询数据库失败！');
    }else{
      res.send(data);
    }
  });
});

// 删除
首先 通过a标签提交删除的数据请求
删除数据 基于记录中的唯一主键id来删除

4、配置路由

​ 根据页面中配置的路由地址，配置服务端响应的路由

5、在页面中增加ajax请求

​ 把查询的服务端的数据，渲染到页面

// 页面加载时就给服务端发送请求，查询数据库中的留言信息
var url = "http://localhost:3000/bbs/find";
$.get(url,function(data){
    console.log(data);
    for(var i in data){
        var trNode = `<tr>
            <td>${data[i].bbsTitle}</td>
            <td>${data[i].bbsContent}</td>
            <td>
                <a href="#">修改</a>
                <a href="#">删除</a>
            </td>
        </tr>`;
        $('#bbsTab').append(trNode);
    }
});

学生系统项目：详解：

学生系统 开发流程（步骤）

1、新建工程

1.1 用express生成器来新建一个工程
指令： express 工程名称（stums）stu：学生， ms：管理系统
	进入工程文件夹 cd stums
	安装工程的模块依赖 npm install
	安装mongoose模块依赖 npm install mongoose --save
	启动工程项目 npm start
	注：在项目启动后，访问localhost:3000能出来express页面就是 项目启动成功
	端口号的修改 在工程项目下的bin文件夹下修改www文件，把3000端口修改成另一个端口号
	
	端口号的作用：服务器上部署多个服务，给多个服务分配不同端口。每一个服务都能和操作系统正常通信。

2、新建页面

express生成工程项目，已经做了静态资源文件托管，要把新建的页面html放到public文件夹下面即可。

form表单：
action:form表单向服务端提交的动作，给了一个路由地址/stu/add。
method:代表的一个form提交的方法类型（get/post）
submit：按钮结合form表单，自动提交到服务端的点击事件
reset：重置按钮，功能系统自动实现

3、配置路由

根据工程项目中的配置方式，进行students的路由配置
1、先引入students的文件模块（students.js）
	var stuRouter = require('./routes/students.js');
	把stuRouter注册到app对象上 'stu'代表一级路由
	app.use('/stu',stuRouter);
	
2、根据html页面路由配置，在students.js中配置二级路由
把原有的users.js文件复制，粘贴到工程内，再修改名称
配置路由名称后，测试路由地址
http://localhost:3000/stu/add

4、配置数据库链接及mongoose的model模板类型

// 引入mongoose模块
var mon = require('mongoose');
// 调用mon.connect（）链接数据库
mon.connect('mongodb://localhost:27017/students',function(){
    console.log('数据库链接成功！');
});

新建schema和model等模板

// schema、model的配置
var Schema = mon.Schema;

/**
 * 创建一个student的Schema 
 * 参数是一个对象，对象就是用来定义表结构
*/ 
var stuSchema = new Schema({
    num: Number,
    stuname: String,
    birthday: String,
    sex: String,
    className: String
});

/**
 *  model通过schema来生成的
 *  stuTable：对应的是数据库中的表名称
 *  model模板通过定义的stuSchema表结构来生成
 *  */
var stuModel = mon.model('stuTable',stuSchema);

5、在students.js路由中，引入model文件模块，通过model来进行数据库的操作

// 增删查改

6、修改（增加模态框）

// 1、先引入bootstrap相关的文件 css和js文件
// 2、data-toggle="modal" data-target="#myModal" 模态框的调用 通过id值
// 3、使用 delegate() 方法的事件处理程序适用于当前或未来的元素（比如由脚本创建的新元素）。 使用委托的方法
$("#tabId").delegate("#stuUpdate","click",function(){});
// 4、通过jquery增加元素节点的自定义属性，为以后使用（取值）做准备
<a data_id=${students[i]._id}>
    id = $(this).attr('data_id');

7、汇总问题

1、mongoose操作数据库的方法名字太长
2、隐藏域的使用
3、mongoose创建表结构时的数据类型
	数据类型：schema是定义表结构，就是表格存储数据时，数据所对应的单位类型
	全部都写成String类型
4、整体流程
5、给元素自定义属性，在后面取自定义属性的值
	jquery高级时讲解内容，元素标签都有html5，统一给定义了一些属性。
	自定义属性，给dom元素增加一个名称。给这个属性赋值，以备以后使用（查询、分类、修改等业务使用）
6、get提交中参数的传递方式
	"/stu/findStusById?stuId=" + stuId
	从”？“开始，问号前的字符代表路由地址，问号后的字符代表传递的参数
	而传递的参数又是键值对的形式 ?key1=value1&key2=value2 
	
	data = {key:value}
	$.get(url,data,function(){}); 
	
7、

8、mongoose中的操作方法

/**
	findById()
	参数1 ：id的值
	参数2：回调函数，执行findbyid方法后，返回数据
	findbyid数据返回是一个对象，因为通过id只能查询到一条记录，所以返回的数据就是一个对象
	find()方法可以跟不同的查询条件，数据返回的是一个数组，而这种情况下要在页面中遍历数据
**/
1、findById(参数1，参数2);
/
/**
findByIdAndUpdate:通过id查询到这条数据，然后再更新这条数据
参数1：id的值 要修改的记录的id值
参数2：要更新的记录的数据（对象）
参数3：回调函数，是执行findbyidandupdate之后的返回数据
**/
2、findByIdAndUpdate(参数1，参数2，参数3)

3、findByIdAndDelete（）同上

博客用户登录项目详解：

博客系统开发流程

1、新建工程

1.1 用express生成器来新建一个工程
指令： express 工程名称（blog）blog：博客
	进入工程文件夹 cd blog
	安装工程的模块依赖 npm install
	安装mongoose模块依赖 npm install mongoose --save
	启动工程项目 npm start
	注：在项目启动后，访问localhost:3000能出来express页面就是 项目启动成功
	端口号的修改 在工程项目下的bin文件夹下修改www文件，把3000端口修改成另一个端口号
	
	端口号的作用：服务器上部署多个服务，给多个服务分配不同端口。每一个服务都能和操作系统正常通信。

2、新建页面

2.1、登录页面

1、登录页面，登录成功后，提示用户登录成功
2、未注册的用户，在登录页面可以跳转到注册页面

新建bootstrap样式的页面
1、可以先把bootstrap页面的基本模板增加上
2、引入相关的bootstrap文件，css/js等文件

2.2、注册页面

1、注册成功后可以直接跳转到登录页面
2、已完成注册的用户，在注册页面可以跳转到登录页面

3、创建数据库链接

3.1、引入mongoose模块，链接mongodb数据库

3.1、根据mongoose模块，创建Schema、Model；将Model模块抛出

注：抛出的model对象就是用来在路由文件中操作数据库

4、配置路由地址

4.1、新建routes的路由文件
4.2、在app.js中引入新建的路由模块文件，并把路由文件注册到服务对象上
4.3、在路由文件中引入数据库model文件
4.4、根据实际的页面需求，生成一二级路由

5、提交form表单中的数据，将页面数据存储到mongodb数据库

form表单中，action、method、submit之间的关系
post提交的数据，在服务端要通过req.body来解析。

1、校验用户名是否重复（已存在）：不让重名用户注册
	1.1、将用户名发送服务端，在数据库中查找是否存在。
	1.2、如果用户名存在，就提示用户更换用户名，如果不存在，就执行后续流程。
	
注：把用户信息存储到数据库之前就应该提示用户，此用户名已存在