Promise 对象分析

文章目录

• 前言
• 一、Promise 对象是什么？
• 二、使用步骤
  • 1.新建一个Promise 对象
  • 2. resolve（解析）和 reject（拒绝) 两个参数的解析
  • 3.案例分析
• 总结

---

前言

提示：在异步方式读取文件中，会出现很长的代码结构，不方便阅读理解，ES6推出了Promise对象，该对象用于解决异步编程中，回调地狱问题。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、Promise对象是什么？

Promise 对象代表了未来将要发生的事件，用来传递异步操作的消息。

二、使用步骤

1.新建一个Promise 对象

let promise = new Promise(function(resolve, reject) {
    // 异步处理
    // 处理结束后、调用resolve 或 reject
});

 2.resolve 或 reject解析

//Promise 构造函数包含一个参数和一个带有 resolve（解析）和 reject（拒绝）两个参数的回调。在回调中执行一些操作（例如异步），如果一切都正常，则调用 resolve，否则调用 reject。

 3.案例分析

 列如: 读取a.txt文件，如果有内容，再读取b.txt文件，如果有内容，再读取c.txt文件，如果有内容，再读取d.txt文件(我们可以通过4种方式来处理)

1.异步方式读取文件

fs.readFile('./files/a.txt',function(err,a){
    if(!err){
        fs.readFile('./files/b.txt',function(err,b){
            if(!err){
                fs.readFile('./files/c.txt',function(err,c){
                    if(!err){
                        fs.readFile('./files/d.txt',function(err,d){
                            if(!err){
                                console.log('1.'+d.toString());
                            }
                        })
                    }
                })
            }
        })
    }   
})
// 注意观察上面的代码结构，层次非常深，特别不方便代理的阅读。我们将这样的代码结构称之为：回调地狱。

2.封装一个Promise对象，在里面读取第一个文件

new Promise(function(resolve,reject){
    // resolve，用于返回正确的结果
    // reject，用于返回错误信息
    fs.readFile('./files/a.txt',function(err,a){
        if(!err){
            resolve(a.toString())
        }
    })
})
.then(function(r){
    // 程序只能能进入到then，就表示之前的操作是成功，就要读取第二个文件；继续封装一个Promise对象，在里面读取第二个文件。
    return new Promise(function(resolve){
        fs.readFile('./files/b.txt',function(err,b){
            if(!err){
                resolve(b.toString())
            }
        })
    })
})
.then(function(r){
    return new Promise(function(resolve){
        fs.readFile('./files/c.txt',function(err,c){
            if(!err){
                resolve(c.toString())
            }
        })
    })
})
.then(function(r){
    return new Promise(function(resolve){
        fs.readFile('./files/d.txt',function(err,c){
            if(!err){
                resolve(c.toString())
            }
        })
    })
})
.then(function(r){
    console.log('2.'+r);
})

3.使用Promise编程，都会把公共的部分进行重新封装简写

function myRead(url){
    return new Promise((resolve,reject)=>{
        fs.readFile(url,(err,data)=>{
            if(!err){
                resolve(data.toString())
            }
        })
    })
}

myRead('./files/a.txt')
.then(r=>{
    // 返回的Promise对象里面的返回结果，通过下一个then的回调函数去接收结果。
    // 这种调用方式，称之为：链式调用。
    return myRead('./files/b.txt')
})
.then(r=>{
    return myRead('./files/c.txt')
})
.then(r=>{
    return myRead('./files/d.txt')
})
.then(r=>{
    console.log('3.'+r);
})

 4.async关键字优化Promise对象

async function run(){
    // 在异步函数中，通过await关键字获取，Promise对象里面的返回结果。
    // await关键字的作用是异步等待，必须等到有返回结果，程序才会继续往下执行。
    // await让异步代码，看上去像同步代码一样，其实本质上还是异步代码。
    // 注意：await关键字，只能在async函数中使用。
    await myRead('./files/a.txt')
    await myRead('./files/b.txt')
    await myRead('./files/c.txt')
    let d = await myRead('./files/d.txt')
    console.log('4.'+d);
}
run()

---

总结

提示：在日常开发中，面对层次非常深不好理解的代码建议用Promise对象对象进行操作