精华内容
下载资源
问答
  • 1、前提 js的同步异步问题通常是指ajax的回调。 如果是同步调用,程序在发出ajax调用后就会暂停,直到远程服务器产生回应后才会继续运行;而如果是异步调用,...async await 它是基于promise的,为什么es6新增了这

    1、前提

    js的同步和异步问题通常是指ajax的回调。

    如果是同步调用,程序在发出ajax调用后就会暂停,直到远程服务器产生回应后才会继续运行;而如果是异步调用,程序发出ajax调用后不会暂停,而是立即执行后面的代码,服务器返回信息后会自动触发回调函数进行处理。

    相比较而言,异步调用的性能最佳,程序不会出现卡顿的现象,而同步调用则通常用于需要立即获得结果并实时处理的情况。

    2、正文

    promise是ES6,async/await是ES7

    异步编程的最高境界就是不关心它是否是异步。async、await很好的解决了这一点,将异步强行转换为同步处理。

    async/await与promise不存在谁代替谁的说法,因为async/await是寄生于Promise,Generater的语法糖。

    async await 它是基于promise的,为什么es6新增了这个?为了解决大量复杂不易读的Promise异步的问题才出现的。async/await相对于promise来讲,写法更加优雅

    3、async

    async必须声明的是一个function

    async test= function () {
         return "我是个promise返回值" 
    };
    //语法错误  async必须声明的是一个function
    

    async 是“异步”的意思,所以应该很好理解 async 用于申明一个 异步的function,返回的是一个Promise对象!

    async function test() {
            return "我是个promise返回值"   // return Promise.resolve("我是个promise返回值")
          }
    test();
    // Promise {<fulfilled>: "我是个promise返回值"}
    

    由上可以,返回的是一个promise,不过可以理解为一个状态为fulfilled,并且已经拿到了返回值为"我是个promise返回值"的promise ,或者可以理解为return Promise.resolve(“我是个promise返回值”),同理如果没有返回值也是Promise.resolve(underfind),下面我们来验证下,后面接个回调函数!

    async function test() {
              return "我是个promise返回值"   // return Promise.resolve("我是个promise返回值")
          }
    test().then(result=>console.log('111',result))
    //  111 我是个promise返回值
    //  Promise {<fulfilled>: undefined}
    

    是这样的!那么对待async要像对待Promise一样去对待async的返回值。

    4、await

    (1)await是干啥的

    await必须是在这个async声明的函数内部使用,意思就是async和await是配对使用的,await存在于async的内部,必须是直系,否则会报错!

    async function test() {
        function test1() {
            await 111;
        };
    };
    // Uncaught SyntaxError: await is only valid in async functions and the top level bodies of modules
    

    async 函数返回一个 Promise 对象,当函数执行的时候,一旦遇到 await 就会先返回,等到触发的异步操作完成,再接着执行函数体内后面的语句。

    (为了验证,请看下面代码)

    async function test() {
        await setTimeout(() => {
            console.log("我是不是最开始执行")
        }, 1000);
        console.log('我什么时候执行');
    }
    test();
    // 我什么时候执行
    //(1s后)我是不是最开始执行
    

    我们发现,并不是像我们预期的那样,先打印‘我是不是最开始执行’,而是从下面先开始执行了?。
    这里是有条件的,如果await后面是 promise对象,会将promise异步操作转为同步等待 promise的resolve / reject 返回结果,再接着执行函数体内后面的语句!
    ( 继续测试下)

    async function test() {
        await new Promise((resolve, reject) => {
            setTimeout(() => {
                console.log("我是不是最开始执行")
            }, 1000);
        });
        console.log('我什么时候执行');
    }
    test();
    // (1s后) 我是不是最开始执行
    

    我们发现,这跟预期的还是不一样。最下面的 console.log(‘我什么时候执行’)没执行。
    原来是如果await的是一个promise对象,那么要等待这个对象解析完成;
    如果没有 resolve 或者 reject ,那么后面的内容就不会执行!
    (我们进行修改,再测试一下)

    async function test() {
        await new Promise((resolve, reject) => {
            setTimeout(() => {
                resolve();
                console.log("我是不是最开始执行")
            }, 1000);
        });
        console.log('我什么时候执行');
    }
    test(); 
    // (1s后) 我是不是最开始执行    
    // (1s后,和上面同时) 我什么时候执行
    
    (2)小结论

    所以我们可以得出一个结论
    (1)await后面如果不是一个promise对象,那么它就按正常的js顺序执行,先执行同步代码,当主线程空闲了,再去执行异步队列的任务!

    (2)await后面如果是promise对象,那么await后面的内容还是相当于在then执行,跟promise的区别在于,如果等待的是一个promise对象,那么要等待这个对象解析完成,如果没有resolve或者reject,那么后面的内容就不会执行;如果有resolve或者reject,那么后面的内容正常执行

    async function test() {
         console.log("async1");
         await new Promise((resolve, reject) => {
             resolve()
         });
         console.log('async2');
     };
     //等价于
     async function test() {
         console.log("async1");
         await new Promise((resolve, reject) => {
             resolve()
         }).then(() => console.log('async2'));
     };
    
    async function fn2() {
        await 2
        console.log(2)
    }
    //等价于
    async function fn2() {
        Promise.resolve(2).then(() => console.log(2))
    }
    
    (3)await的返回值
    async function test() {
        let result = await new Promise((resolve, reject) => {
            setTimeout(() => {
                resolve('返回的值');
            }, 1000);
        });
       console.log('111',result) 
       // 上面的等价于Promise.resolve(result).then(() => console.log(‘111’,result));
       return result;
    };
    test().then((data) =>
        console.log(data)
    )
    // (1s后) 111 返回的值
    // (1s后) 返回的值
    

    我们可以发现,await 的返回值是promise的resolve/reject 返回结果,然后通过执行async函数 retrun出来,相当于 Promise.resolve("返回结果")!

    5、一道面试题

    既然说到了这里,看下面的一道宏任务和微任务的面试题!

    async function test() {
        console.log("async1");
        await new Promise((resolve, reject) => {
            resolve(1)
        });
        console.log('async2');
    };
    setTimeout(function () {
        console.log("setTimeout");
    }, 0);
    test();
    new Promise(function (resolve) {
        console.log("promise1");
        resolve();
    }).then(function () {
        console.log("promise2");
    });
    console.log('end');
    

    相信很多人都会做错,那么我们来分析下!

    1. 执行第一轮宏任务,发现setTimeout是个宏任务,0秒后直接扔到宏任务异步队列!
    2. 执行test(),先输出"async1",继续执行await,因为后面是个promise对象,所以会"阻塞"后面的任务,直到拿到1这个结果。这里是重点:发现await后面有个console.log(‘async2’),则根据刚才的知识,我们知道执行完await后面的promise,那么后面的代码都是在promise.then()里面执行,所以console.log('async2')是个微任务!,把它扔进异步队列!
    3. 执行new Promise,执行同步代码输出"promise1",then()后面又是个微任务,扔进任务异步队列!
    4. 执行同步代码输出’end’!
    5. 一轮宏任务执行完毕,看下有没有微任务,执行第一个微任务输出’async2’,再执行第二个微任务"promise2",微任务执行结束,再执行第二轮宏任务!
    6. 最后执行宏任务输出"setTimeout"

    所以执行结果是

    async1
    promise1
    end
    async2
    promise2
    setTimeout
    

    6、async抛出异常

    async函数相当于对多个Promise的封装,所以必须等到内部所有的await命令执行完,才会改变自己的状态为resolved除非碰到return语句或者抛出了异常
    也就是说,正常情况下 只有async函数内部的异步操作执行完,才会执行then后面的语句。

    当async函数抛出异常时或者await的返回值reject状态,Promise 的 reject 方法也会传递这个异常值!

    async function test() {
        throw Error("获取错误")
    };
    test().catch((error) =>
        console.log(error)
    );
    //Error: 获取错误
    

    只要一个await后面的Promise变为rejected,整个async函数就会中断执行,整个async返回的Promise对象就会是rejected状态。

    async function test() {
        let result = await new Promise((resolve, reject) => {
            setTimeout(() => {
                reject("获取返回值失败");
            }, 1000);
        });
        //reject后,后面console.log('111',result)代码不执行了
        console.log('111',result) 
        return result;
    };
    test().catch((error) =>
        console.log('222',error)//获取‘返回值失败’
    );
    // 222 获取返回值失败
    
    async function f() {
      	await Promise.reject('出错了');
      	await Promise.resolve('hello world'); // 这行代码不会执行
    }
    

    因为第一个await后面的对象reject了,所以整个async函数就中断执行了

    有时,我们希望即使前一个异步操作失败,也不要中断后面的异步操作。
    这时可以将第一个await放在try…catch结构里面,这样不管这个异步操作是否成功,第二个await都会执行。

    await命令后面的Promise对象,运行结果可能是rejected,所以最好把await命令放在try…catch代码块中。

    7、try catch

    try catch是JavaScript的异常处理机制,把可能出错的代码放在try语句块中,如果出错了,就会被catch捕获来处理异常。如果不catch 一旦出错就会造成程序崩溃。

    如果有多个await命令,可以将其都放在try catch结构中,如果执行出错,catch会去捕获异常

    async function f() {
        try {
         	await Promise.reject('出错了');
         	console.log('上面已经出错了'); //这行代码不会执行
         	return await Promise.resolve('hello world'); //这行代码不会执行
        } catch(e) {
            console.log('111',e);
        }
     }
      
    f()
    .then(v => console.log('222',v))
    .catch(k => console.log('333' , k))
    // 111 出错了
    // 222 undefined
    

    catch会去捕获 try 代码块中的错误,只要有一个抛出了异常,就不会继续执行
    所以上面的代码不会打印“上面已经出错了” ,也不会执行“return await Promise.resolve(‘hello world’)”;
    因为使用了try catch 所以 async 是顺利执行完成的,其中的报错 被 try catch处理了,所以异常不会被async返回的Promise的catch捕获,因此async返回的Promise对象状态是resolved。

    8、async await 和promise相比的优势

    async await是promise的进化版,async await 相比原来的Promise的优势在于处理 then链,不必把回调嵌套在then中,只要await 即可
    我们来模拟下一个场景,有3个请求,但是有顺序的,必须要先执行第一个,再执行第二个,最后执行第三个,并且1秒后执行第一个请求,执行完第一个请求后,3秒后执行第二个请求,执行完第二个请求后,5秒后执行第三个请求!

    promise会这样写

    let request1 = (time) => {
         return new Promise((resolve, reject) => {
             setTimeout(() => {
                 resolve('request1返回的值');
             }, time * 1000);
         });
     };
    
     let request2 = (time) => {
         return new Promise((resolve, reject) => {
             setTimeout(() => {
                 resolve('request2返回的值');
             }, time * 1000);
         });
     };
    
     let request3 = (time) => {
         return new Promise((resolve, reject) => {
             setTimeout(() => {
                 resolve('request3返回的值');
             }, time * 1000);
         });
     };
    
     request1(1).then((data) => {
         console.log(data);//request1返回的值
         return request2(3)
     }).then((data) => {
         console.log(data);//request3返回的值
         return request3(5)
     }).then((data) => {
         console.log(data)//request3返回的值
     })
    

    async await 会这样写

    async function request() {
        let resolve1 = await request1(1);
        console.log(resolve1);
        resolve2 = await request2(3);
        console.log(resolve2);
        resolve3 = await request3(5);
        console.log(resolve3);
    }
    request();
    

    —————————————————————————————————

    (本文部分参考博主「世态炎凉!!」的文章,原文链接:https://blog.csdn.net/ws9029/article/details/111402211

    展开全文
  • 异步回调Async AwaitPromise区别

    千次阅读 2020-12-19 18:39:20
    async await 它是基于promise的,为什么es6新增了这个?为了解决大量复杂不易读的Promise异步的问题才出现的,首先async await是有密切联系的!下面分别来介绍下它们的之前的关系! 1、async async必须声明的是一个...

    async await 它是基于promise的,为什么es6新增了这个?为了解决大量复杂不易读的Promise异步的问题才出现的,首先async await是有密切联系的!下面分别来介绍下它们的之前的关系!

    1、async

    async必须声明的是一个function!

    async test= function () {
         return "我是个promise返回值" 
    };
    //语法错误  async必须声明的是一个function
    

    async 是“异步”的意思,所以应该很好理解 async 用于申明一个 异步的function,返回的是一个Promise对象!

    async function test() {
              return "我是个promise返回值"   // return Promise.resolve("我是个promise返回值")
          }
    test();
    // Promise {<fulfilled>: "我是个promise返回值"}
    

    返回的是一个promise,不过可以理解为一个状态为fulfilled并且已经拿到了返回值为"我是个promise返回值"的promise 或者可以理解为return Promise.resolve(“我是个promise返回值”),同理如果没有返回值也是Promise.resolve(underfind),下面我们来验证下,后面接个回调函数!

    async function test() {
        return "我是个promise返回值"
    }
    test().then((response) => {
        console.log(response); //我是个promise返回值
    })
    

    是这样的!那么对待async要像对待Promise一样去对待async的返回值!(有点绕口,知道这个意思就可以!)下面我们来看下 await

    2、await

    await必须是在这个async声明的函数内部使用,必须是直系,否则报错!

    async function test() {
        function test1() {
            await 111;
        };
    };
    //Uncaught SyntaxError: await is only valid in async function
    

    阮一峰老师说:async 函数返回一个 Promise 对象,当函数执行的时候,一旦遇到 await 就会先返回,等到触发的异步操作完成,再接着执行函数体内后面的语句。是这样吗?我们来测试下!

    async function test() {
        await setTimeout(() => {
            console.log("我是不是最开始执行")
        }, 1000);
        console.log('我什么时候执行');
    }
    test();
    //我什么时候执行
    // 1s之后 我是不是最开始执行
    

    我擦?不对啊! 怎么下面先开始执行了? 这里是有条件的,如果await后面是 promise对象,会将promise异步操作转为同步,等待 promise的resolve/reject 返回结果.,再接着执行函数体内后面的语句!继续测试下!

    async function test() {
        await new Promise((resolve, reject) => {
            setTimeout(() => {
                console.log("我是不是最开始执行")
            }, 1000);
        });
        console.log('我什么时候执行');
    }
    test();//我是不是最开始执行
    

    怎么又不对?为什么下面 console.log(‘我什么时候执行’)没执行,是不是哪里写错了?原来是如果await的是一个promise对象,那么要等待这个对象解析完成,如果没有resolve或者reject那么后面的内容就不会执行!再改下!

    async function test() {
        await new Promise((resolve, reject) => {
            setTimeout(() => {
                resolve();
                console.log("我是不是最开始执行")
            }, 1000);
        });
        console.log('我什么时候执行');
    }
    test(); // 1s之后 我是不是最开始执行    我什么时候执行
    

    和阮老师说的貌似一致了!那么得出一个结论!如果await后面如果不是一个promise对象那么它就按正常的js顺序执行,先执行同步代码,当主线程空闲了,再去执行异步队列的任务!既然说到了这里,那么再讲深入一点点!js的执行机制大家应该知道!宏任务和微任务等(不懂的可以点击这里),看下面的一道面试题!

    async function test() {
        console.log("async1");
        await new Promise((resolve, reject) => {
            resolve(1)
        });
        console.log('async2');
    };
    setTimeout(function () {
        console.log("setTimeout");
    }, 0);
    test();
    new Promise(function (resolve) {
        console.log("promise1");
        resolve();
    }).then(function () {
        console.log("promise2");
    });
    console.log('end');
    

    相信很多人都会做错,那么我们来分析下!

    1. 执行第一轮宏任务,发现setTimeout是个宏任务,0秒后直接扔到宏任务异步队列!
    2. 执行test(),先输出"async1",直接执行await,因为后面是个promise对象,所以会"阻塞"后面的任务,直到拿到1这个结果,这里是重点发现console.log('async2')是个微任务,扔进微任务异步队列,执行完await后面的promise,那么后面的代码都是在promise.then()里面执行,所以console.log('async2')是个微任务!
    3. 执行new Promise,执行同步代码输出"promise1", then后面又是个微任务,扔进任务异步队列!
    4. 执行同步代码输出’end’!
    5. 一轮宏任务执行完毕,看下有没有微任务,执行第一个微任务输出’async2’,再执行第二个微任务"promise2",微任务执行结束,再执行第二轮宏任务!
    6. 最后执行宏任务输出"setTimeout"
    7. 所以执行结果是"async1",“promise1”,‘end’,‘async2’,“promise2”,“setTimeout”

    上面说的偏题了,主要想说的是await后面如果不是一个promise对象那么它就是按正常js执行顺序(先同步后异步),是promise对象那么await后面的内容还是相当于在then执行,跟promise的区别在于如果等待的是一个promise对象,那么要等待这个对象解析完成,如果没有resolve或者reject那么后面的内容就不会执行

    async function test() {
         console.log("async1");
         await new Promise((resolve, reject) => {
             resolve()
         });
         console.log('async2');
     };
     //等价于
     async function test() {
         console.log("async1");
         await new Promise((resolve, reject) => {
             resolve()
         }).then(() => console.log('async2'));
     };
    
    async function fn2() {
        await 2
        console.log(2)
    }
    //等价于
    async function fn2() {
        Promise.resolve(2).then(() => console.log(2))
    }
    

    接着正题说,那么await有返回值吗?返回值是什么?

    async function test() {
        let result = await new Promise((resolve, reject) => {
            setTimeout(() => {
                resolve('返回的值');
            }, 1000);
        });
       console.log(result) //返回的值
       // 等价于Promise.resolve(result).then(() => console.log(result));
       return result;
    };
    test().then((data) =>
        console.log(data)//返回的值
    )
    

    看上面的例子可以发现await 的返回值就是promise的resolve/reject 返回结果,然后通过执行async函数 retrun出来,相当于 Promise.resolve("返回结果")!

    当async函数抛出异常时或者await 的返回值reject状态 ,Promise 的 reject 方法也会传递这个异常值!

    async function test() {
        throw Error("获取错误")
    };
    test().catch((error) =>
        console.log(error)
    );
    //Error: 获取错误
    
    async function test() {
        let result = await new Promise((resolve, reject) => {
            setTimeout(() => {
                reject("获取返回值失败");
            }, 1000);
        });
        console.log(result) //失败后后面代码不执行了
        return result;
    };
    test().catch((error) =>
        console.log(error)//获取返回值失败
    );
    

    3、async await 和promise相比的优势

    async await是promise的进化版,async await 相比原来的Promise的优势在于处理 then链,不必把回调嵌套在then中,只要await 即可 我们来模拟下一个场景,有3个请求,但是有顺序的,必须要先执行第一个,再执行第二个,最后执行第三个,并且1秒后执行第一个请求,执行完第一个请求后,3秒后执行第二个请求,执行完第二个请求后,5秒后执行第三个请求!平时工作中应该很多这种需求!

    promise会这样写

    let request1 = (time) => {
         return new Promise((resolve, reject) => {
             setTimeout(() => {
                 resolve('request1返回的值');
             }, time * 1000);
         });
     };
    
     let request2 = (time) => {
         return new Promise((resolve, reject) => {
             setTimeout(() => {
                 resolve('request2返回的值');
             }, time * 1000);
         });
     };
    
     let request3 = (time) => {
         return new Promise((resolve, reject) => {
             setTimeout(() => {
                 resolve('request3返回的值');
             }, time * 1000);
         });
     };
    
     request1(1).then((data) => {
         console.log(data);//request1返回的值
         return request2(3)
     }).then((data) => {
         console.log(data);//request3返回的值
         return request3(5)
     }).then((data) => {
         console.log(data)//request3返回的值
     })
    

    async await 会这样写

    async function request() {
        let resolve1 = await request1(1);
        console.log(resolve1);
        resolve2 = await request2(3);
        console.log(resolve2);
        resolve3 = await request3(5);
        console.log(resolve3);
    }
    request();
    

    是不是没有冗余的长长的链式代码,语义化也非常清楚,看起来很舒服!,本来想把async await 如何捕获异常也写了,想不想还是下篇再补完吧!

    展开全文
  • 关于async await 和promise

    2019-07-23 16:43:27
    promise是es6出来的用来解决异步回调问题的新的api, 通过promise我们会发现 确实会比回调函数写起来要方便很多,也可以用来进行异步转同步的作用,但是当我用了 async await之后发现,这个写法更加的方便,是用...

    promise是es6出来的用来解决异步回调问题的新的api, 通过promise我们会发现 确实会比回调函数写起来要方便很多,也可以用来进行异步转同步的作用,但是当我用了 async 和 await之后发现,这个写法更加的方便,是用同步的方式在写异步代码(只需要将await放在上面就行了) 而且也不用 .then() 将代码包进去,确实方便不少,看起来更加简洁,但问题是,只要放在上面,他就会阻止下面的代码执行,而有时候你并不想一棍子打死所有代码的时候,这时候可以使用 promise代替,总的来说 async await 还是特别的好用的

    展开全文
  • // 执行 async 函数,返回的都是 Promise 对象 async function test1() { return 1 } async function test2() { return Promise.resolve(2) } const res1 = test1() const res2 = test2()
    // 执行 async 函数,返回的都是 Promise 对象
            async function test1() {
                return 1
            }
            async function test2() {
                return Promise.resolve(2)
            }
            
            const res1 = test1()
            const res2 = test2()
            
            console.log(res1)   //自动返回一个 Promise
            console.log(res2)
    

    在这里插入图片描述

    // Promise.then 成功的情况 对应 await
                async function test3() {
                const p3 = Promise.resolve(3)
    
                p3.then(res => {
                    console.log('p3', res)     //p3 3
                })
    
                const a3 = await p3
                console.log('a3', a3)  //a3 3   返回结果都是 3
                }
                test3()
                
                //也可以跟一个函数 ,test1()是上面的
                async function test4() {
                const data4 = await test1()  // 等价 await Promise.resolve(test1())
                console.log('res4', data4)   // res4 1        返回值为 test1() 的值
                }
                test4()
    
     //  Promise.catch 异常的情况 对应 try...catch
                async function test5() {
                const p5 = Promise.reject(5);
    
                try {
                    const data5 = await p5;
                    console.log('data5', p5)
                } catch (e) {
                    console.log('e', e)      // e 5
                }
                }
                test6()
    
    展开全文
  • async await 和promise的使用

    千次阅读 2018-05-25 23:55:50
    async 是“异步”的简写,而 await 可以认为是 async wait 的简写。所以应该很好理解 async用于申明一个 ...详细说明:async 是让方法变成异步,在终端里用 node 执行这段代码,你会发现输出了 Promise {‘Hel...
  • async awaitPromise

    2020-08-06 18:12:37
    Promise只能依靠then触发执行 可以想象resolve等于then reject=catch ...async/await 相比原来的Promise的优势在于处理 then 链,不必把回调嵌套在then中,只要await 即可 但用await来获取结果的话代码结构就...
  • 1、带async关键字的函数,它是得函数的...如果不是promiseawait会阻塞后边的代码,先执行async外边的同步代码,同步代码执行完成后再回到async内部,把这个非promise的东西,作为await表达式的结果 如果是p...
  • async awaitpromise

    2021-01-21 19:49:59
    async 返回值相当于返回了一个promise 对象 await 可以理解为执行了promise对象的resolve方法,至于resolve方法更深层的东西,那就需要不了解的同学自己去研究了。 promise 首先,通过一段代码来看一下promise...
  • async await对比promise的优缺点 async/await优点: a. 它做到了真正的串行的同步写法,代码阅读相对容易 b. 对于条件语句其他流程语句比较友好,可以直接写到判断条件里面 c. 处理复杂流程时,在代码清晰度方面有...
  • 异步ajax请求之间可能会有依赖情况,本篇以定时器模拟请求,总结了几种通过async await和Promise将异步转为同步的方案 // get1请求、get2请求 function get1 () { return new Promise((resolve, reject) => { ...
  • 当我们想依次执行多个异步请求时,或者实现setTimeout为setInterval时,可以使用Promise对象和async await关键字来实现该功能。 尤其是,我们在使用node做网络爬虫时,需要进行大量的依次进行的异步请求。 波及到...
  • async awaitpromise

    2019-10-05 14:10:55
    1.async 的返回值一定是一个promise。,即使你的函数里没有return. // 测试async的返回值 async function testAsync() { } let result = testAsync(); console.log(result); // 结果 Promise { undefined...
  • async await 代替promise

    万次阅读 2018-08-15 14:14:43
    const request = require('request');...const makeRequest = async () =&gt; { try { let msg = await __get(); console.log(msg); } catch(err) { console.log(err); } # promise的写法 // __...
  • async和awaitpromise区别

    千次阅读 2020-06-07 20:50:53
    async和awaitpromise区别一、什么是Async/Await?二、区别二、为什么Async/Await更好? 一、什么是Async/Await? async/await是写异步代码的新方式,以前的方法有回调函数 Promiseasync/await是基于...
  • return new Promise((resolve,reject)=>{ // 抛出错误 reject('throw error') }) } async function getres() { try { console.log('first') let res = await fn() // 捕获错误,遇到错误,中断下面输出...
  • js异步回调Async/AwaitPromise区别

    万次阅读 2018-09-09 18:10:18
    Promise,我们了解到...你是不是我一样对Async/Await感兴趣以及想知道如何使用,下面一起来看看这篇文章:Async/Await替代Promise的6个理由。 什么是Async/Await? async/await是写异步代码的新方式,以前的...
  • 求下题运行结果 async function async1(){ ... await async2(); console. log('async1 end'); } async function async2(){ console.log('async2'); } ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 39,642
精华内容 15,856
关键字:

asyncawait和promise区别