ES6——Promise 、ayanc 和 await 相关知识点

最新推荐文章于 2024-07-26 20:46:33 发布

Bonsoir777

最新推荐文章于 2024-07-26 20:46:33 发布

阅读量499

点赞数 5

分类专栏： ES6 文章标签： es6 javascript 前端 ajax

本文链接：https://blog.csdn.net/Bonsoir777/article/details/126815115

版权

ES6 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

文章目录

前言
一、Promise
- 1. 什么是Promise?
- 2. Promise 的三种状态
- 3. 基本用法
- 4. 模拟异步
- 5. 执行步骤
- 6. 封装ajax
- 7. Proimse.prototype.then 方法
- 8. Promise.prototype.catch( )方法
二、async 和 await 方法
- 1. async 函数
- 2. await表达式
总结

一、Promise

1. 什么是Promise?

Promise是异步编程的一种解决方案，可以替代传统的解决方案--回调函数和事件。ES6统一了用法，并原生提供了Promise对象。作为对象，Promise有以下两个特点：

对象的状态不受外界影响。

Promise对象代表一个异步操作，有三种状态：pending（进行中）、fulfilled（已成功）和rejected（已失败）。只有异步操作的结果，可以决定当前是哪一种状态，任何其他操作都无法改变这个状态。这也是Promise这个名字的由来，它的英语意思就是“承诺”，表示其他手段无法改变。

一旦状态改变了就不会在变，也就是说任何时候Promise都只有一种状态。

Promise对象的状态改变，只有两种可能：从pending变为fulfilled和从pending变为rejected。只要这两种情况发生，状态就凝固了，不会再变了，会一直保持这个结果，这时就称为 resolved（已定型）。

2. Promise 的三种状态

Pending状态（进行中）Fulfilled状态（已成功） Rejected状态（已失败）

一旦发生改变就只有一种状态：Pending -> Fulfilled Pending -> Rejected。

3. 基本用法

Resolve，用来接收完成状态，reject用来接收失败的状态。

<script>
        console.log('1');
        // 创建Promise对象，有一个函数，函数里有两个参数,参数1 resolve 成功的回调,  参数2 reject  失败的回调
        const Mypromise = new Promise((resolve, reject) => {
            console.log('2');
            // 利用延迟定时器模拟异步
            setTimeout(() => {
                resolve( '成功的数据！');
            }, 3000);
        })
        console.log('3');
        // promise 的 then 方法, then  方法中有两个参数，分别是两个函数，分别对应 new Promise 中的两个参数
        Mypromise.then((resolve) => {
            // 成功的业务逻辑
            console.log('5' + resolve);
        }, (reject) => {
            // 失败的业务逻辑
            console.log(reject);
        })
        console.log('4');
    </script>

说明：then方法可以接受两个回调函数作为参数。第一个回调函数是Promise对象的状态变为resolved时调用，第二个回调函数是Promise对象的状态变为rejected时调用。这两个函数都是可选的，不一定要提供。它们都接受Promise对象传出的值作为参数。

4. 模拟异步

4.1 什么是异步

我们知道程序的执行流程是自上而下依次执行的，但有时可能会出现某段代码块的执行需要依赖其他代码块执行的结果，这就构成了异步的执行顺序。简单来说：异步可以理解为当你做某件事的执行顺序为：一边做某事，一边做另一件事。

function timeout(ms){
return new Promise(function(relove,reject){
                                        setTimeout(()=>{
                                                console.log('程序'+ms +'毫秒后打印！');

                                        },ms);    

                                })

}

timeout(3000);

5. 执行步骤

<script>
        console.log('1');
        // 创建Promise对象，有一个函数，函数里有两个参数,参数1 resolve 成功的回调,  参数2 reject  失败的回调
        const Mypromise = new Promise((resolve, reject) => {
            console.log('2');
            // 利用延迟定时器模拟异步
            setTimeout(() => {
                resolve( '成功的数据！');
            }, 3000);
        })
        console.log('3');
        // promise 的 then 方法, then  方法中有两个参数，分别是两个函数，分别对应 new Promise 中的两个参数
        Mypromise.then((resolve) => {
            // 成功的业务逻辑
            console.log('5' + resolve);
        }, (reject) => {
            // 失败的业务逻辑
            console.log(reject);
        })
        console.log('4');
    </script>

说明：Promise 新建后立即执行，所以首先输出的是Promise。然后，then方法指定的回调函数，将在当前脚本所有同步任务执行完才会执行，所以4最后输出。

6. 封装ajax

  <script>
        // 通过封装函数的方法，使用promise封装ajax
        // 声明一个函数
        function sendAjax(url) {
            //创建一个promise 实例对象并返回
            return new Promise((resolve, reject) => {
                // 创建 ajax 对象
                const ajax = new XMLHttpRequest();
                // 打开一个新的ajax地址,参数1，请求方式，参数2，请求地址
                ajax.open('GET', url);
                // 发送请求
                ajax.send();
                // 判断服务器状态
                ajax.onreadystatechange = function () {
                    if (ajax.readystate == 4) {//判断服务器状态码是否成功
                        let data = json.parse(data.lists);  //模拟获取数据
                        if (ajax.status == 2) {
                            console.log(ajax.response);
                        }
                    }
                }
            })
        }

        // 调用函数,
        const Promise = sendAjax();
        // 调用promise then 方法
        Promise.then((resolve) => {
            console.log(resolve);
        }, (reject) => {
            console.log(reject);
        })
    </script>

7. Proimse.prototype.then 方法

Promise 实例具有then方法，也就是说，then方法是定义在原型对象Promise.prototype上的。它的作用是为 Promise 实例添加状态改变时的回调函数。then方法的第一个参数是resolved状态的回调函数，第二个参数是rejected状态的回调函数，参数可选。

then方法返回的是一个新的Promise实例（注意，不是原来那个Promise实例）。因此可以采用链式写法，即then方法后面再调用另一个then方法。根据这一特性我们可以采用链式方法：

7.1 then 和 setTimeout 的执行机制。

其实，setTimeout 是同步执行的, then 是异步执行的。

如上图所示，程序会先执行区域 1，执行完毕后，依次执行区域 2
但是！！此时区域 2 的执行需要获取到区域 3 的执行结果，这就是 then 的异步执行
而 setTimeout 只是把某些区域的执行顺序通过时间的延迟放在了事件队列的最后面，从而给我们一种异步执行的感觉。

 function sayhi(){
                      
                           let mypromise = new Promise(function(resolve,reject){

                                   let str = "hello world";

                                   resolve(str);

                           })

                           return mypromise;

                   }

                        sayhi().then(function(value){

                                console.log(value);

                                return value;

                        }).then(function(value){

                                console.log(value+2);

                                return value;

})

8. Promise.prototype.catch( )方法

Promise.prototype.catch()方法是.then(null, rejection)或.then(undefined, rejection)的别名，用于指定发生错误时的回调函数。

let myfun = function(){
                     
        let mypromise = new Promise(function(resolve,reject){

                    reject('错误');

        })

        return mypromise;

}

     //发生错误的时捕获

myfun().catch(function(e){

        console.error(e);

});

二、async 和 await 方法

async和await两种语法结合可以让异步代码像同步代码一样。

1. async 函数

async 是一个修饰符，async 定义的函数会默认的返回一个Promise对象resolve的值，因此对async函数可以直接进行then操作,返回的值即为then方法的传入函数。

举例：

async function fn(){

                   //1.如果返回的是一个非Promise的对象，则fn（）返回的结果就是成功状态的Promise对象，值为返回值

                   //2.如果返回的是一个Promise对象，则fn（）返回的结果与内部Promise对象的结果一致

                   //3.如果返回的是抛出错误，则fn（）返回的就是失败状态的Promise对象

                   return new Promise((resolve,reject)=>{

                           resolve('成功的数据');

                   });

}

const result = fn();

result.then(

                value=>{

                   console.log(value) //成功的数据

                },reason=>{

                   console.log(reason) //失败的数据

})

2. await表达式

它也是一个修饰符，await 关键字只能放在 async 函数内部， await关键字的作用 就是获取 Promise中返回的内容， 获取的是Promise函数中resolve值。

1：await必须放在async函数中

2：await右侧的表达式一般为promise对象

3：await可以返回的是右侧promise成功的值

4：await右侧的promise如果失败了，就会抛出异常，需要通过try…catch捕获处理

举例：

const bbb = function(){ return 'string'}



async function funAsy() {

                   const a = await 1

                   const b = await new Promise((resolve, reject)=>{

                        setTimeout(function(){

console.log(‘b执行了’)

                           resolve('time')

                        }, 3000)

                   })

                   const c = await bbb()

                   console.log(a, b, c)

}



funAsy() // 运行结果是 3秒钟之后，输出 1， time , string

如果Promise 不加await 会立刻输出 1 string，3秒后输入：”b执行了”。