Node.js02--06

发表于 | 分类于 ， ， | 本文总阅读量 次
字数统计: 1.5k | 阅读时长 ≈ 6

使用node操作MySQL数据库

安装：
npm install --save mysql

新建

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//0 、引包
var mysql = require('mysql');
//1、创建连接
var connection = mysql.createConnection({
	host:'localhost',
	user:'root',
	password:'123',
	database:'users'
	});

//2、连接数据库 打开冰箱门
connection.connect();

//3、执行数据操作，把大象放到冰箱中
//选择数据
<!-- connect.query('SELECT * FROM `users`',function(err,res,fields){
	if(err) throw error
	}); -->

//就只有connect.query方法，所有的增删改查都在该方法内部填写，通过前面的mysql语句来进行数据库操作
//增加数据
<!-- connect.query('INSERT INTO users VALUES("admin","123456")',function(err,res,fields){
	if(err) throw error
	}); -->

//4、关闭连接，关闭冰箱门
connect.end();

总结

  • mongodb数据库
    • 数据存储结构
    • 数据表
    • 集合（表）
    • 文档（表记录）
  • mongodb 官方有一个mongodb的包用来操作mongodb数据库
    • 比较原始，使用比较麻烦，一半不用该包
  • mongoose
    • 真正公司进行开发，使用的是mongoose第三方包
    • 提高开发效率
  • 掌握使用mongodb对数据集合进行基本的CRUD
  • 使用node操作mysql数据库

回调地狱 callback hell

throw error

抛出异常：
两个作用：
1、阻止程序的执行
2、把错误信息打印到控制台

对于异步编程会出现的问题：
异步指的是不一定会按照程序代码的顺序进行执行，而是根据操作系统的调度行和文件大小以及一些偶然性决定的，所以是不一定按照编写顺序来的
例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
var fs = require('fs');
fs.readFile('./data/a.txt','utf-8',function(err,data){
	if(error) throw error
	console.log(data);
	});


fs.readFile('./data/b.txt','utf-8',function(err,data){
	if(error) throw error
	console.log(data);
	});


fs.readFile('./data/c.txt','utf-8',function(err,data){
	if(error) throw error
	console.log(data);
	});

即以上文件的读取顺序不一定是a.txt b.txt c.txt的顺序来进行读取的

解决以上办法就是通过回调嵌套的方式来保证顺序
例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
var fs = require('fs');
fs.readFile('./data/a.txt','utf-8',function(err,data){
	if(error) throw error
	console.log(data);


fs.readFile('./data/b.txt','utf-8',function(err,data){
	if(error) throw error
	console.log(data);



fs.readFile('./data/c.txt','utf-8',function(err,data){
	if(error) throw error
	console.log(data);


	});

	});

	});

不停在内部进行嵌套，但是当回调的程序多了以后，就会不停的嵌套，形成回调地狱。一个任务依赖一个异步任务以后，就把该任务写到异步任务里面，形成回调关系。问题就是嵌套太深，代码很丑，不易维护，阅读困难

Promise

为了解决回调地狱嵌套，所以在ES6中新增了一个API：Promise

可以把Promise看作是一个容器，容器中存放了一个异步任务，该异步任务包括三种状态，pending（默认状态），resolved（成功）、rejected（失败）。pending指向这俩个状态，并且每次只能变成一种，单向的，只能从pending–>resolved或者pending–>rejected。

  • Promise是一个构造函数
  • Promise本身不是异步，但它里面的任务是异步的，即内部往往都是封装一个异步任务

基本语法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
var fs = require('fs');
//0、创建Promise容器
//1、给别人一种承诺I Promise You
//Promise容器一旦创建，就开始执行里面的代码

var p1 = new Promise(function(resolve,reject){
	fs.readFile('./data/a.txt','utf8',function(err,data){
		if(err){
			//承诺容器中的任务失败了
			//把容器的pending状态改为rejected
			//调用reject就相当于调用了then方法的第二个参数函数
			reject(err)
			} else {
			//承诺容器中的任务成功了
			//把容器的pending状态改成resolved
			//也就是说这里调用的resolve方法实际上就是then方法传递的哪个function
			resolve(123);
			}
		});
	});

//p1就是哪个Promise，实例对象
//当p1成功了 然后（then）做指定的操作
//then方法接受的function就是容器中的resolve函数
p1
 .then(function(data){
 	console.log(data);//123，上面传递的resolve参数是123，所以打印出来就是123
 	},function(err){
 		console.log('读取文件失败了',err);
 		});

嵌套解决

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
var fs = require('fs');


//创建三个文件读取实例
//a.txt
var p1 = new Promise(function(resolve,reject){
	fs.readFile('./data/a.txt','utf8',function(err,data){
		if(err){
			reject(err)
			} else {
			resolve(data);
			}
		});
	});

//b.txt
var p2 = new Promise(function(resolve,reject){
	fs.readFile('./data/b.txt','utf8',function(err,data){
		if(err){
			reject(err)
			} else {
			resolve(data);
			}
		});
	});

//c.txt
var p3 = new Promise(function(resolve,reject){
	fs.readFile('./data/c.txt','utf8',function(err,data){
		if(err){
			reject(err)
			} else {
			resolve(data);
			}
		});
	});

p1
 .then(function(data){
 	console.log(data);
 	//当p1读取成功的时候
 	//当前函数中return的结果就可以在后面的 then中function接收到
 	//当return 123 后面就接受到123
 	//return 'hello'，后面就接受到hello，没有return后面就接受到undefined
 	//上面那些数据没什么用，真正有用的是我们可以return一个Promise对象
 	//当return一个Promise对象的时候，后续的then中方法的第一个参数会作为P2的resolve
 	//第二个参数会作为p2的reject方法
 	return p2
 	},function(err){
 		console.log('读取文件失败了',err);
 		})
 .then(function(data){
 	console.log(data);
 	return p3;
 	},function(err){
 		console.log(err);
 		})
 .then(function(data){
 	console.log(data)
 	},function(err){
 		console.log(err);
 		})

封装Promise版本的readFile

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
var fs = require('fs');



function pReadFile(filepath){
	return new Promise(function(resolve,reject){
	fs.readFile(filepath,'utf8',function(err,data){
		if(err){
			reject(err)
			} else {
			resolve(data);
			}
		});
	});
}

pReadFile('./data/a.txt')

   .then(function(data){
   	console.log(data);
   	return pReadFile('./data/b.txt');//返回一个新建的b文件pb实例
   	},function(err){
   		console.log(err+'1');
   		})

   .then(function(data){
   	console.log(data);
   	return pReadFile('./data/c.txt');//返回一个新建的c文件pc实例
   	},function(err){
   		console.log(err+'2');
   		})

   .then(function(data){
   	console.log(data)
   	},function(err){
   		console.log(err+'3');
   		})

Promise和数据库操作

所有数据库操作都是异步的

~
//用户注册
//1、判断用户是否存在，如果已存在，结束注册，否则注册（保存一条用户信息）
User.findOne({
username:’admin’
})
.then(function(user){
if(user){
//用户已存在，不能注册
console.log(‘用户已存在’)
} else {
//用户不存在，可以注册
return new User({
username:’aaa’,
paaword:’123’,
email:’sas’
})
}
})
.then (function(ret){

})
-------------本文结束感谢您的阅读-------------