promise作用：为了解决回调地狱问题，但并不能减少代码量，将多次的嵌套变成并联
1）Promise是一个构造函数，可以new Promise
2）在promise中有两个函数 resolve和reject 成功和失败之后的回调函数
3）在promise的prototype中有一个.then方法，只要是promise构造函数创建的实例，都可以访问到 .then方法
4）如果promise表示一个异步操作，每当new一个promise实例，这个实例，就表示一个具体的异步操作；
5）既然promise创建的实例是一个异步操作，那么这个操作的结果只有两种
5.1成功：需要在内部调用 成功的回调函数 resolve
5.2失败：需要在内部调用 失败的回调函数 reject
5.3由于是异步操作，所以内部拿到操作的结果后是无法使用return把操作的结果返回给调用者，需要使用回调函数返回给调用者
6）可以在new出来的promise实例上调用.then方法，预先为promise异步操作指定成功和失败的回调函数
此时只知道这是一个异步，但不知道是什么的异步
var promise=new Promise
此时知道了异步操作是什么，异步操作是通过function定义的
var promise=new Promise(function () {
fs.readFile("2","utf8",(err,data)=>{
if(err) throw err
console.log(data);
})
})
当new一个对象时，就会立即执里面的异步操作回调函数
为了不立即执行，把new对象的过程放在函数里，调用函数的时候，才会执行异步操作
function getfile(){
var promise=new Promise(function () {
fs.readFile("2","utf8",(err,data)=>{
if(err) throw err
console.log(data);
})
})
}
用函数包装起来，用的时候调用函数，此时执行里面的回调函数，不调用时，不执行
带来的问题，因为是个异步操作，所以不会有返回内容，为了有返回，引入resolve和reject
function getfile(){
var promise=new Promise(function (resolve, reject) {
fs.readFile("2","utf8",(err,data)=>{
if(err) reject(err)
resolve(data)
})
})
return promise
}
var p=getfile() //这里得到了方法中的promise （因为函数返回的是promise）但是里面的函数是异步函数，所以不执行
//先执行个return
//得到promise实例，调用then方法，规定reject和resolve
//下面这句话就是把 resolve和reject具体化
p.then(function (data) {
console.log(data + "~~~~");
},function (err) {
console.log(err.message);
})
执行顺序
1 定义函数
2 执行getfile（）方法
3 运行函数 函数中new promise
4 return promise
5 接收这个return
6 用then定义resolve和reject
7 进行异步操作代码
function getfile(){
return promise=new Promise(function (resolve, reject) {
fs.readFile("2","utf8",(err,data)=>{
if(err) reject(err)
resolve(data)
})
})
}
getfile() .then(function (data) {
console.log(data + "~~~~");
},function (err) {
console.log(err.message);
})
promise解决地狱回调，
getfile("1")
.then(function (data) {
console.log(data);
return getfile("2")
})
.then(function (data) {
console.log(data);
return getfile("3")
})
.then(function (data) {
console.log(data);
})
对于执行顺序
getfile("1")
.then(function (data) {
console.log(data);
return getfile("2")
})
.then(function (data) {
console.log(data);
return getfile("3")
})
.then(function (data) {
console.log(data);
})
console.log("~~~~~~");
结果
~~~~~~
111111111
2222222222
33333333333
因为最后一句是主程序中的，其他三个是异步操作，主程序先不执行
需求：遇到err的promise，继续执行下面的promise，不影响后面的promise
方法：添加reject函数，函数中return 下一个promise
getfile("11")
.then(function (data) {
console.log(data);
return getfile("2") //这里其实已经生成了一个对应 2 的promise对象，我们用return把它拿出来
},function (err) {
console.log("失败" + err.message); //这里失败了，但是下面的内容还要执行，所有return 2
return getfile("2")
})
.then(function (data) {
console.log(data);
return getfile("3")
})
.then(function (data) {
console.log(data);
})
console.log("~~~~~~");
需求：每一层promise之间是依赖关系，一个promise err 其余的都不执行
方法：不是添加reject函数，在最后添加catch函数
getfile("11")
.then(function (data) {
console.log(data);
return getfile("2") //这里其实已经生成了一个对应 2 的promise对象，我们用return把它拿出来
})
.then(function (data) {
console.log(data);
return getfile("3")
})
.then(function (data) {
console.log(data);
}).catch(function (err) {
console.log(err.message);
})
catch的作用：如果前面任何promise失败，则立即终止后面的promise，立马进入catch去处理promise中抛出的异常
