ES6 async await

  1 <!DOCTYPE html>
  2 <html lang="en">
  3 <head>
  4     <meta charset="UTF-8">
  5     <title>async-await</title>
  6 </head>
  7 <body>
  8     <h3>ES6 async 函数用法</h3>
  9
 10     <script>
 11
 12         window.onload = function() {
 13
 14             // 例-1: 继发异步
 15             async function f() {
 16                 try {
 17                     let a = await new Promise((resolve, reject) => {setTimeout(resolve.bind(null, ‘hello‘), 1000)});
 18                     console.log(‘a: ‘, a);
 19                     let b = await new Promise((resolve, reject) => {setTimeout(resolve.bind(null, ‘world‘), 2000)});
 20                     console.log(‘b: ‘, b);
 21                     let c = await new Promise((resolve, reject) => {setTimeout(resolve.bind(null, ‘xyz‘), 3000)});
 22                     console.log(‘c: ‘, c);
 23                     return c;
 24                 } catch(error) {
 25                     console.log(‘error: ‘, error);
 26                 }
 27             }
 28             // 继发调用: 回调嵌套, 抛出最后结果, f() 只用来作为一个流程管理器
 29             // f().then(v => {console.log(‘final-result: ‘+ v);}).catch(e => {console.log(‘final-error-reason: ‘, e);});
 30
 31
 32             // 例-2: 并发异步
 33             async function g() {
 34                 try {
 35                     return await Promise.all([
 36                         ajax1(‘https://api.github.com/users/github‘, ‘get‘),
 37                         ajax2(‘https://api.github.com/users‘, ‘get‘),
 38                         ajax3(‘https://api.github.com‘, ‘get‘),
 39                         ajax4(‘https://api.github.com/users/chosen‘, ‘get‘)
 40                     ]);
 41                 } catch(error) {
 42                     console.log(‘error: ‘, error);
 43                 }
 44             }
 45
 46             /*
 47             * https://api.github.com/users/github
 48             * https://api.github.com/users
 49             * https://api.github.com
 50             * https://api.github.com/users/chosen
 51             */
 52
 53             // 并发调用: 全部执行完才抛出最后结果, g() 只用来作为一个流程管理器
 54             g().then(obj => {
 55                 let[github, users, api, chosen] = obj; // 解构
 56                 let [jGithub, jUsers, jApi, jChosen] = [JSON.parse(github), JSON.parse(users), JSON.parse(api), JSON.parse(chosen)]; // 解构转成 js 对象
 57                 // 业务流程
 58                 console.log(‘---------- all-completed ----------‘);
 59                 console.log(‘github >>>>>>‘, jGithub[‘login‘]);
 60                 console.log(‘users >>>>>>‘, jUsers[0][‘login‘]);
 61                 console.log(‘api >>>>>>‘, jApi[‘current_user_url‘]);
 62                 console.log(‘chosen >>>>>>‘, jChosen[‘login‘]);
 63             }).catch(e => {
 64                 console.log(e);
 65             })
 66
 67
 68
 69
 70
 71         }
 72
 73         // --------------- function --------------------
 74
 75
 76         // ajax1
 77         function ajax1(url, type) {
 78             return new Promise((resolve, reject) => {
 79                 console.log(‘ajax1 start~‘);
 80                 myAjax(url, type, null, function(data) {
 81                     console.log(‘ajax1-completed!‘);
 82                     resolve(data);
 83                 }, function(reason) {
 84                     console.log(‘ajax1-failed!‘);
 85                     reject(reason);
 86                 })
 87             })
 88         }
 89
 90         // ajax2
 91         function ajax2(url, type) {
 92             return new Promise((resolve, reject) => {
 93                 console.log(‘ajax2 start~‘);
 94                 myAjax(url, type, null, function(data) {
 95                     console.log(‘ajax2-completed!‘);
 96                     resolve(data);
 97                 }, function(reason) {
 98                     console.log(‘ajax2-failed!‘);
 99                     reject(reason);
100                 })
101             })
102         }
103
104         // ajax3
105         function ajax3(url, type) {
106             return new Promise((resolve, reject) => {
107                 console.log(‘ajax3 start~‘);
108                 myAjax(url, type, null, function(data) {
109                     console.log(‘ajax3-completed!‘);
110                     resolve(data);
111                 }, function(reason) {
112                     console.log(‘ajax3-failed!‘);
113                     reject(reason);
114                 })
115             })
116         }
117
118         // ajax4
119         function ajax4(url, type) {
120             return new Promise((resolve, reject) => {
121                 console.log(‘ajax4 start~‘);
122                 console.log(‘---------- cut-off-line ----------‘);
123                 myAjax(url, type, null, function(data) {
124                     console.log(‘ajax4-completed!‘);
125                     resolve(data);
126                 }, function(reason) {
127                     console.log(‘ajax4-failed!‘);
128                     reject(reason);
129                 })
130             })
131         }
132         // 以上 4 个函数(ajax1 ~ ajax4)可以进一步封装, 但为了表达清晰, 此处不做处理
133
134
135         // 自定义 ajax, 类型仅限于 get 和 post, 回调函数: success/error
136         function myAjax(url, type, params, success, error) {
137             var xhr = null;
138             var args = null;
139             xhr = new XMLHttpRequest();
140             xhr.onreadystatechange = function() {
141                 if (xhr.readyState == 4) {
142                     if ((xhr.status >= 200 && xhr.status < 300) || xhr.status == 304) {
143                         success(xhr.responseText);
144                     } else {
145                         error("Request was unsuccessful: "+ xhr.status);
146                     }
147                 }
148             };
149             xhr.open(type, url, true); // 类型, 连接, 是否异步
150             if (type.toLowerCase() == ‘post‘) {
151                 // xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded"); // 默认的表单提交
152                 xhr.setRequestHeader("Content-Type", "application/json; charset=UTF-8"); // JSON.stringify 处理后的json 键值对
153                 args = params;
154             }
155             xhr.send(args);
156         }
157     </script>
158 </body>
159 </html>

原文地址:https://www.cnblogs.com/Rainscoco/p/9082330.html

时间: 2024-10-08 12:27:11

ES6 async await的相关文章

async包 ES6 async/await的区别

最基本的async 包 ApCollection.find({}).toArray(function (err, aps) { var num = 0; async.whilst( function () { return num++ < aps.length; }, function (callback) { if (aps[num]) { var apmac = aps[num].AP_MAC; ApHeartCollection.findOne({ AP_MAC: apmac, time:

ES6 async/await语法

Async/await的主要益处是可以避免回调地狱(callback hell)问题 Chromium JavaScript引擎 从v5.5开始支持async/await功能,Chromium JavaScript引擎版本号的查看方法是:在浏览器地址栏输入 chrome://version,查询出来的信息如下图所示: 这意味着async/await不再是实验性功能,使用它时无需指定--harmony参数,此参数用来开启那些几乎已完成但被V8团队认为还不稳定的功能.不同的node版本使用不同的V8

JS学习- ES6 async await使用

async 函数是什么?一句话,它就是 Generator 函数的语法糖. 使用场景常常会遇到,请求完一个接口,拿完值再去请求另外一个接口,我们之前回调callback函数处理,如果很多的情况下,看起来很冗余,这时我们可以用async函数. 比如我们有两个请求,如下,这里用的axios: function getCode(){ return axios.get('json/code.json'); } function getlist(params){ return axios.get('jso

ES6 Async/Await 完爆Promise的6个原因

自从Node的7.6版本,已经默认支持async/await特性了.如果你还没有使用过他,或者对他的用法不太了解,这篇文章会告诉你为什么这个特性"不容错过".本文辅以大量实例,相信你能很轻松的看懂,并了解Javascript处理异步的一大杀器. 文章灵感和内容借鉴了6 Reasons Why JavaScript's Async/Await Blows Promises Away (Tutorial),英文好的同学可以直接戳原版参考. 初识Async/await 对于还不了解Async

Javascript中的async await

async / await是ES7的重要特性之一,也是目前社区里公认的优秀异步解决方案.目前,async / await这个特性已经是stage 3的建议,可以看看TC39的进度,本篇文章将分享async / await是如何工作的,阅读本文前,希望你具备Promise.generator.yield等ES6的相关知识. 在详细介绍async / await之前,先回顾下目前在ES6中比较好的异步处理办法.下面的例子中数据请求用Node.js中的request模块,数据接口采用Github v3

从async await 报错Unexpected identifier 谈谈对上下文的理解

原文首发地址:http://www.cnblogs.com/lonhon/p/7518231.html 先简单介绍下async await: async/await是ES6推出的异步处理方案,目的也很明确:更好的实现异步编程.   详细见阮大神 ES6入门 现在说说实践中遇到的问题:使用await报错Unexpected identifier 先上代码: var sleep = function (time) { return new Promise(function (resolve, rej

ES7 Async/Await 陷阱

什么是Async/Await ES6新增了Promise函数用于简化项目代码流程.然而在使用promise时,我们仍然要使用callback,并且并不知道程序要干什么,例如: function doSomething() { let i = 0; waitOneSecond() // 返回一个Promise对象 .then(() => console.log(i)); i = 5; } 最终console.log(i) 的结果是5,并不是0 为此,ES7引入了async函数,前面的例子可以改写这

体验异步的终极解决方案-ES7的Async/Await

阅读本文前,期待您对promise和ES6(ECMA2015)有所了解,会更容易理解.本文以体验为主,不会深入说明,结尾有详细的文章引用. 第一个例子 Async/Await应该是目前最简单的异步方案了,首先来看个例子. 这里我们要实现一个暂停功能,输入N毫秒,则停顿N毫秒后才继续往下执行. 1 var sleep = function (time) { 2 return new Promise(function (resolve, reject) { 3 setTimeout(function

ES7的Async/Await的简单理解

Async/Await 的个人见解 正文: async,顾名思义,一个异步执行的功能,而 await 则是配合 async 使用的另一个关键字,也是闻字识其意,就是叫你等待啦! 二者配合食用效果更佳哦,就像德芙配巧克力 ⊙_⊙|| 现在其实有点意识的前端或者JS学习者基本都学习了ES6语法了,但是依旧感觉在编写异步代码上不够爽怎么办,在 ES7 的 async/await 则能使得我们在编写异步代码时变得像同步一样的方式来编写,这样子可以帮助我们更直观的阅读我们的额代码而不必在一堆代码中去寻找这