promise

目录

promise的使用——大量异步操作（且需顺序执行）

 链式调用

1.封装promise函数

2.根据顺序，形成链式调用

3.捕获错误

---

promise的使用——大量异步操作（且需顺序执行）

通过回调函数执行——回调地狱，故通过promise对象解决

1.new一个promise对象

var promise=new promise({

})

2.promise对象里面有回调函数，有两个参数：resolve： 异步处理成功，reject：失败  （resolve,reject）resolve,reject顺序不要反

3.手动终止———通过抛出一个错误

   throw new Error('手动终止')

 链式调用

const fs=require('fs');
//封装
function isEixt(){
    return new Promise((resolve,reject)=>{
        fs.stat('./hehe.js',(err,stats)=>{
            if(err){
                reject('文件不存在')
            }else{
                resolve('文件存在')
            }
        })
    })
}
function delFile(){
    return new Promise((resolve,reject)=>{
        fs.unlink('./hehe.js',(err)=>{
            if(err){
                reject('del no ok')
            }else{
                resolve('del ok')
            }
        })
        
    })
}
isEixt()
.then(()=>{
    console.log('is exit 的成功处理')
    return delFile();
})
.then(()=>{
    console.log('delfile 的成功处理')
    //手动终止
    throw new Error('手动终止')
})
.then(()=>{//后面没有promise对象的也会执行.then()
    console.log('text111')
})
.then(()=>{
    console.log('text222')
})
.catch((err)=>{
    console.log('catch');
    console.log('我是err:'+
    err)
})

封装promise函数

在创建的函数中，第一件事返回一个promise对象，在promise对象里加上两个参数，在回调函数里写需要的异步处理，在成功是调用resolve，失败reject

function test(){

//返回promise

return new Promise(（resolve，reject）=>{

        //需要的异步处理

        成功的时候 resolve

        失败的时候 reject

})

}