Promise

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中抛出的异常