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 [email protected]

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、validatesaveremove`方法

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模板


<html>
   <head>
      <title>Bootstrap 模板title>
      <meta name="viewport" content="width=device-width, initial-scale=1.0">
      
      <link href="./bootstrap/css/bootstrap.min.css" rel="stylesheet">
   head>
   <body>
      <h1>Hello, world!h1>
       
      <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 = `
            ${data[i].bbsTitle}
            ${data[i].bbsContent}
            
                修改
                删除
            
        `;
        $('#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、如果用户名存在,就提示用户更换用户名,如果不存在,就执行后续流程。
	
注:把用户信息存储到数据库之前就应该提示用户,此用户名已存在	
	

你可能感兴趣的:(node.js笔记)