金沙棋牌官方平台

当前位置:金沙棋牌 > 金沙棋牌官方平台 > 异步JavaScript的发展历程,从回调函数到

异步JavaScript的发展历程,从回调函数到

来源:http://www.logblo.com 作者:金沙棋牌 时间:2019-11-09 19:47

异步JavaScript进化史

2015/10/14 · CSS

本文由 伯乐在线 - cucr 翻译,唐尤华 校稿。未经许可,禁止转载!
英文出处:Gergely Nemeth。欢迎加入翻译组。

async函数近在眼前,但这经过了很长的旅程。不久前我们还在写回调,接着是Promise/A+规范,之后出现 generator函数,现在是async函数。

让我们回头看看异步JavaScript在这些年是如何发展的。

原文出处: @晓风well   

用 Async 函数简化异步代码

2017/04/08 · JavaScript · 异步

原文出处: Joe Zimmerman , Nilson Jacques   译文出处:oschina   

Promise 在 JavaScript 上发布之初就在互联网上流行了起来 — 它们帮开发人员摆脱了回调地狱,解决了在很多地方困扰 JavaScript 开发者的异步问题。但 Promises 也远非完美。它们一直请求回调,在一些复杂的问题上仍会有些杂乱和一些难以置信的冗余。

随着 ES6 的到来(现在被称作 ES2015),除了引入 Promise 的规范,不需要请求那些数不尽的库之外,我们还有了生成器。生成器可在函数内部停止执行,这意味着可把它们封装在一个多用途的函数中,我们可在代码移动到下一行之前等待异步操作完成。突然你的异步代码可能就开始看起来同步了。

这只是第一步。异步函数因今年加入 ES2017,已进行标准化,本地支持也进一步优化。异步函数的理念是使用生成器进行异步编程,并给出他们自己的语义和语法。因此,你无须使用库来获取封装的实用函数,因为这些都会在后台处理。

运行文章中的 async/await 实例,你需要一个能兼容的浏览器。

现代 JS 流程控制:从回调函数到 Promises 再到 Async/Await

2018/09/03 · JavaScript · Promises

原文出处: Craig Buckler   译文出处:OFED   

JavaScript 通常被认为是异步的。这意味着什么?对开发有什么影响呢?近年来,它又发生了怎样的变化?

看看以下代码:

result1 = doSomething1(); result2 = doSomething2(result1);

1
2
result1 = doSomething1();
result2 = doSomething2(result1);

大多数编程语言同步执行每行代码。第一行执行完毕返回一个结果。无论第一行代码执行多久,只有执行完成第二行代码才会执行。

回调

一切都始于回调

对大部分的JavaScript开发者而言,async函数是个新鲜事物,它的发展经历了一个漫长的旅程。因此本文试图 梳理总结JavaScript异步函数的发展历程:在不久之前,我们还只能写回调函数来实现异步,然后Promise/A+ 标准出来了,这之后又出现了生成器函数,而未来显然是async函数的。

运行兼容

在客户端,Chrome、Firefox 和 Opera 能很好地支持异步函数。

图片 1

(点击图片进行页面跳转)

从 7.6 版本开始,Node.js 默认启用 async/await。

单线程处理程序

JavaScript 是单线程的。当浏览器选项卡执行脚本时,其他所有操作都会停止。这是必然的,因为对页面 DOM 的更改不能并发执行;一个线程
重定向 URL 的同时,另一个线程正要添加子节点,这么做是危险的。

用户不容易察觉,因为处理程序会以组块的形式快速执行。例如,JavaScript 检测到按钮点击,运行计算,并更新 DOM。一旦完成,浏览器就可以自由处理队列中的下一个项目。

(附注: 其它语言比如 PHP 也是单线程,但是通过多线程的服务器比如 Apache 管理。同一 PHP 页面同时发起的两个请求,可以启动两个线程运行,它们是彼此隔离的 PHP 实例。)

异步JavaScript

异步编程,就像我们现在知道在JavaScript中,只能通过该语言的一等公民函数来实现:它们可以像任何其他变量一样传递给其他函数。这就是回调诞生的原因:如果你传递一个函数到另一个函数(或称为高阶函数)作为参数,当工作完成时你可以调用该函数。回调没有返回值,只传值并调用另一个函数。

JavaScript

Something.save(function(err) { if (err) { //error handling return; } console.log('success'); });

1
2
3
4
5
6
7
Something.save(function(err) {  
  if (err)  {
    //error handling
    return;
  }
  console.log('success');
});

这些所谓的错误优先(error-first)回调是Node.js自身的核心——核心模块以及NPM上的大多数模块都使用了它。

回调的挑战:

  • 如果使用不当,很容易构建回调地狱或意大利面条式代码。
  • 错误处理很容易被忽视。
  • 不能通过return语句返回值,也不能使用throw关键字。

正因为这些问题,使得JavaScript世界开始寻找可以使异步JavaScript开发变得更容易的解决方案。

答案之一是async 模块。如果你大量使用回调,就会发现并行或顺序运行程序,甚至使用异步函数映射数组会有多复杂。async模块的诞生需要感谢 Caolan McMahon。

使用async,你可以轻松地这样做:

JavaScript

async.map([1, 2, 3], AsyncSquaringLibrary.square, function(err, result){ // result will be [1, 4, 9] });

1
2
3
4
async.map([1, 2, 3], AsyncSquaringLibrary.square,  
  function(err, result){
  // result will be [1, 4, 9]
});

不过,这并不容易阅读和编写,所以有了Promises。

现在让我们、一起来回顾这些年来JavaScript异步函数的发展历程吧。

异步函数和生成器对比

这有个使用生成器进行异步编程的实例,用的是 Q 库:

var doAsyncOp = Q.async(function* () {   var val = yield asynchronousOperation();   console.log(val);   return val; });

1
2
3
4
5
var doAsyncOp = Q.async(function* () {
  var val = yield asynchronousOperation();
  console.log(val);
  return val;
});

Q.async 是个封装函数,处理场景后的事情。其中 * 表示作为一个生成器函数的功能,yield 表示停止函数,并用封装函数代替。Q.async 将会返回一个函数,你可对它赋值,就像赋值 doAsyncOp 一样,随后再调用。

ES7 中的新语法更简洁,操作示例如下:

async function doAsyncOp () {   var val = await asynchronousOperation();        console.log(val);   return val; };

1
2
3
4
5
async function doAsyncOp () {
  var val = await asynchronousOperation();     
  console.log(val);
  return val;
};

差异不大,我们删除了一个封装的函数和 * 符号,转而用 async 关键字代替。yield 关键字也被 await 取代。这两个例子事实上做的事是相同的:在 asynchronousOperation 完成之后,赋值给 val,然后进行输出并返回结果。

通过回调实现异步

单线程产生了一个问题。当 JavaScript 执行一个“缓慢”的处理程序,比如浏览器中的 Ajax 请求或者服务器上的数据库操作时,会发生什么?这些操作可能需要几秒钟 – 甚至几分钟。浏览器在等待响应时会被锁定。在服务器上,Node.js 应用将无法处理其它的用户请求。

解决方案是异步处理。当结果就绪时,一个进程被告知调用另一个函数,而不是等待完成。这称之为回调,它作为参数传递给任何异步函数。例如:

doSomethingAsync(callback1); console.log('finished'); // 当 doSomethingAsync 完成时调用 function callback1(error) { if (!error) console.log('doSomethingAsync complete'); }

1
2
3
4
5
6
7
doSomethingAsync(callback1);
console.log('finished');
 
// 当 doSomethingAsync 完成时调用
function callback1(error) {
  if (!error) console.log('doSomethingAsync complete');
}

doSomethingAsync() 接收回调函数作为参数(只传递该函数的引用,因此开销很小)。doSomethingAsync() 执行多长时间并不重要;我们所知道的是,callback1() 将在未来某个时刻执行。控制台将显示:

finished doSomethingAsync complete

1
2
finished
doSomethingAsync complete

Promises

当今JavaScript的Promise规范可以追溯到2012年,从ES6时可以使用——然而Promises并非从JavaScript社区诞生。这个词于1976年来自 Daniel P. Friedman 。

promise代表异步操作的最终结果。

以前关于Promises的示例看起来像这样:

JavaScript

Something.save() .then(function() { console.log('success'); }) .catch(function() { //error handling })

1
2
3
4
5
6
7
Something.save()  
  .then(function() {
    console.log('success');
  })
  .catch(function() {
    //error handling
  })

你会注意到,Promises理所当然地使用了回调。then 和 catch 注册的回调函数要么由异步操作结果触发,要么当无法满足预期条件时调用。Promises的另一个优点是可以链式操作:

JavaScript

saveSomething() .then(updateOtherthing) .then(deleteStuff) .then(logResults);

1
2
3
4
saveSomething()  
  .then(updateOtherthing)
  .then(deleteStuff)  
  .then(logResults);

在使用Promises时你可能需要在不支持它的运行环境中使用polyfills。一个受欢迎的选择是使用bluebird。这些库可以提供比原生更多的功能,特别是在Promises/A+规范提供的特性受到限制的情况下。

但是你为什么不使用sugar方法?请读 Promises: 扩展的问题。了解Promises的更多信息,请参阅 Promises/A+ 规范。

你可能会问:当大部分库只仅仅公开一个回调接口时,我如何使用Promises?

这很简单——你唯一要做的就是使用一个Promise封装原始的回调函数,像这样:

JavaScript

function saveToTheDb(value) { return new Promise(function(resolve, reject) { db.values.insert(value, function(err, user) { // remember error first ;) if (err) { return reject(err); // don't forget to return here } resolve(user); }) } }

1
2
3
4
5
6
7
8
9
10
function saveToTheDb(value) {  
  return new Promise(function(resolve, reject) {
    db.values.insert(value, function(err, user) { // remember error first ;)
      if (err) {
        return reject(err); // don't forget to return here
      }
      resolve(user);
    })
  }
}

一些库、框架已经都已经支持,提供一个回调和同时提供Promise接口。如果你今天创建了一个库,同时支持回调和Promise接口是一种很好的实践。你可以很容易地这样做:

JavaScript

function foo(cb) { if (cb) { return cb(); } return new Promise(function (resolve, reject) { }); }

1
2
3
4
5
6
7
8
function foo(cb) {  
  if (cb) {
    return cb();
  }
  return new Promise(function (resolve, reject) {
 
  });
}

甚至更简单,你可以选择从一个仅支持Promise的接口开始,并通过工具提供向后兼容,比如callbackify。Callbackify基本上做了和之前显示的代码片段相同的工作,但方法更简单。

回调函数 Callbacks

似乎一切应该从回调函数开始谈起。

将 Promises 转换成异步函数

如果我们使用 Vanilla Promises 的话前面的示例将会是什么样?

function doAsyncOp () {   return asynchronousOperation().then(function(val) {     console.log(val);     return val;   }); };

1
2
3
4
5
6
function doAsyncOp () {
  return asynchronousOperation().then(function(val) {
    console.log(val);
    return val;
  });
};

这里有相同的代码行数,但这是因为 then 和给它传递的回调函数增加了很多的额外代码。另一个让人厌烦的是两个 return 关键字。这一直有些事困扰着我,因为它很难弄清楚使用 promises 的函数确切的返回是什么。

就像你看到的,这个函数返回一个 promises,将会赋值给 val,猜一下生成器和异步函数示例做了什么!无论你在这个函数返回了什么,你其实是暗地里返回一个 promise 解析到那个值。如果你根本就没有返回任何值,你暗地里返回的 promise 解析为 undefined。

回调地狱

通常,回调只由一个异步函数调用。因此,可以使用简洁、匿名的内联函数:

doSomethingAsync(error => { if (!error) console.log('doSomethingAsync complete'); });

1
2
3
doSomethingAsync(error => {
  if (!error) console.log('doSomethingAsync complete');
});

一系列的两个或更多异步调用可以通过嵌套回调函数来连续完成。例如:

async1((err, res) => { if (!err) async2(res, (err, res) => { if (!err) async3(res, (err, res) => { console.log('async1, async2, async3 complete.'); }); }); });

1
2
3
4
5
6
7
async1((err, res) => {
  if (!err) async2(res, (err, res) => {
    if (!err) async3(res, (err, res) => {
      console.log('async1, async2, async3 complete.');
    });
  });
});

不幸的是,这引入了回调地狱 —— 一个臭名昭著的概念,甚至有专门的网页介绍!代码很难读,并且在添加错误处理逻辑时变得更糟。

回调地狱在客户端编码中相对少见。如果你调用 Ajax 请求、更新 DOM 并等待动画完成,可能需要嵌套两到三层,但是通常还算可管理。

操作系统或服务器进程的情况就不同了。一个 Node.js API 可以接收文件上传,更新多个数据库表,写入日志,并在发送响应之前进行下一步的 API 调用。

Generators、yield函数

JavaScript Generators是一个相对较新的概念,他们从ES6(也称为ES2015)引入。

是不是很好,当你执行你的函数时,可以在任何时候暂停,计算其他东西,做其他事情,然后返回,带一些返回值并继续?

这正是generator函数为你做的。当我们调用generator函数时它并不会开始运行,我们需要手工迭代。

JavaScript

function* foo () { var index = 0; while (index < 2) { yield index++; } } var bar = foo(); console.log(bar.next()); // { value: 0, done: false } console.log(bar.next()); // { value: 1, done: false } console.log(bar.next()); // { value: undefined, done: true }

1
2
3
4
5
6
7
8
9
10
11
function* foo () {  
  var index = 0;
  while (index < 2) {
    yield index++;
  }
}
var bar =  foo();
 
console.log(bar.next());    // { value: 0, done: false }  
console.log(bar.next());    // { value: 1, done: false }  
console.log(bar.next());    // { value: undefined, done: true }

如果你想更容易地使用generator编写异步JavaScript,你将需要co。

Co是基于generator的控制流,对Node.js和浏览器都适用 style="color: #ff0000">。使用promises,可以让你用更好地方式编写非阻塞代码。

使用co,我们之前的例子可能看起来像这样:

JavaScript

co(function* (){ yield Something.save(); }).then(function() { // success }) .catch(function(err) { //error handling });

1
2
3
4
5
6
7
8
co(function* (){  
  yield Something.save();
}).then(function() {
  // success
})
.catch(function(err) {
  //error handling
});

你可能会问:并行操作运行会怎么样?答案可能比你想象的更简单(在底层它只是Promise.all):

JavaScript

yield [Something.save(), Otherthing.save()];

1
yield [Something.save(), Otherthing.save()];

异步JavaScript

正如我们所知道的那样,在JavaScript中,异步编程方式只能通过JavaScript语言中的一等公民函数才能完成: 这种方式意味着我们可以将一个函数作为另一个函数的参数,在这个函数的内部可以调用被传递进来的函数(即回调函数)。 这也正是回调函数诞生的原因:如果你将一个函数作为参数传递给另一个函数(此时它被称为高阶函数),那么在函数内部, 你可以调用这个函数来来完成相应的任务。回调函数没有返回值(不要试图用return),仅仅被用来在函数内部执行某些动作。 看一个例子:

JavaScript

Something.save(function(err) { if (err) { //error handling return; // 没有返回值 } console.log('success'); });

1
2
3
4
5
6
7
Something.save(function(err) {  
    if (err)  {
        //error handling
        return; // 没有返回值
    }
    console.log('success');
});

上面的例子中我们演示了一个错误优先的回调函数(error-first callbacks),这也是Node.js本身的特点之一, Node.js中所有的核心模块和NPM仓库中的大部分模块在编写时都会遵循这个特点。

过度使用回调函数所会遇到的挑战:

  • 如果不能合理的组织代码,非常容易造成回调地狱(callback hell),这会使得你的代码很难被别人所理解。
  • 很容易遗漏错误处理代码
  • 无法使用return语句返回值,并且也不能使用throw关键字

也正是基于这些原因,在JavaScript世界中,一直都在寻找着能够让异步JavaScript开发变得更简单的可行的方案。

一个可行的解决方案之一是async模块。如果你和回调函数打过很久的交道, 你也许会深刻的感受到,在JavaScript中如果想要让某些事并行执行,或是串行执行,甚至是使用异步函数来映射(mapping) 数组中的元素使用异步函数有多复杂。所以,感谢Caolan McMahon写了async模块来 解决这些问题。

使用async模块,你可以轻松像下面这样的方式编写代码:

JavaScript

async.map([1, 2, 3], AsyncSquaringLibrary.square, function(err, result){ // result will be [1, 4, 9] });

1
2
3
4
async.map([1, 2, 3], AsyncSquaringLibrary.square,  
    function(err, result){
        // result will be [1, 4, 9]
});

async模块虽然一定程度上带来了便利,但仍然不够简单,代码也不容易阅读,因此Promise出现了。

链式操作

Promise 之所以能受到众人追捧,其中一个方面是因为它能以链式调用的方式把多个异步操作连接起来,避免了嵌入形式的回调。不过 async 函数在这个方面甚至比 Promise 做得还好。

下面演示了如何使用 Promise 来进行链式操作(我们只是简单的多次运行 asynchronousOperation 来进行演示)。

function doAsyncOp() {   return asynchronousOperation()     .then(function(val) {       return asynchronousOperation(val);     })     .then(function(val) {       return asynchronousOperation(val);     })     .then(function(val) {       return asynchronousOperation(val);     }); }

1
2
3
4
5
6
7
8
9
10
11
12
function doAsyncOp() {
  return asynchronousOperation()
    .then(function(val) {
      return asynchronousOperation(val);
    })
    .then(function(val) {
      return asynchronousOperation(val);
    })
    .then(function(val) {
      return asynchronousOperation(val);
    });
}

使用 async 函数,只需要像编写同步代码那样调用 asynchronousOperation:

async function doAsyncOp () {   var val = await asynchronousOperation();   val = await asynchronousOperation(val);   val = await asynchronousOperation(val);   return await asynchronousOperation(val); };

1
2
3
4
5
6
async function doAsyncOp () {
  var val = await asynchronousOperation();
  val = await asynchronousOperation(val);
  val = await asynchronousOperation(val);
  return await asynchronousOperation(val);
};

甚至最后的 return 语句中都不需要使用 await,因为用或不用,它都返回了包含了可处理终值的 Promise。

Promises

ES2015(ES6) 引入了 Promises。回调函数依然有用,但是 Promises 提供了更清晰的链式异步命令语法,因此可以串联运行(下个章节会讲)。

打算基于 Promise 封装,异步回调函数必须返回一个 Promise 对象。Promise 对象会执行以下两个函数(作为参数传递的)其中之一:

  • resolve:执行成功回调
  • reject:执行失败回调

以下例子,database API 提供了一个 connect() 方法,接收一个回调函数。外部的 asyncDBconnect() 函数立即返回了一个新的 Promise,一旦连接创建成功或失败,resolve()reject() 便会执行:

const db = require('database'); // 连接数据库 function asyncDBconnect(param) { return new Promise((resolve, reject) => { db.connect(param, (err, connection) => { if (err) reject(err); else resolve(connection); }); }); }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
const db = require('database');
 
// 连接数据库
function asyncDBconnect(param) {
 
  return new Promise((resolve, reject) => {
 
    db.connect(param, (err, connection) => {
      if (err) reject(err);
      else resolve(connection);
    });
 
  });
 
}

Node.js 8.0 以上提供了 util.promisify() 功能,可以把基于回调的函数转换成基于 Promise 的。有两个使用条件:

  1. 传入一个唯一的异步函数
  2. 传入的函数希望是错误优先的(比如:(err, value) => …),error 参数在前,value 随后

举例:

// Node.js: 把 fs.readFile promise 化 const util = require('util'), fs = require('fs'), readFileAsync = util.promisify(fs.readFile); readFileAsync('file.txt');

1
2
3
4
5
6
7
// Node.js: 把 fs.readFile promise 化
const
  util = require('util'),
  fs = require('fs'),
  readFileAsync = util.promisify(fs.readFile);
 
readFileAsync('file.txt');

各种库都会提供自己的 promisify 方法,寥寥几行也可以自己撸一个:

// promisify 只接收一个函数参数 // 传入的函数接收 (err, data) 参数 function promisify(fn) { return function() { return new Promise( (resolve, reject) => fn( ...Array.from(arguments), (err, data) => err ? reject(err) : resolve(data) ) ); } } // 举例 function wait(time, callback) { setTimeout(() => { callback(null, 'done'); }, time); } const asyncWait = promisify(wait); ayscWait(1000);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// promisify 只接收一个函数参数
// 传入的函数接收 (err, data) 参数
function promisify(fn) {
  return function() {
      return new Promise(
        (resolve, reject) => fn(
          ...Array.from(arguments),
        (err, data) => err ? reject(err) : resolve(data)
      )
    );
  }
}
 
// 举例
function wait(time, callback) {
  setTimeout(() => { callback(null, 'done'); }, time);
}
 
const asyncWait = promisify(wait);
 
ayscWait(1000);

Async、await函数

Async函数在ES7引入,目前只能使用像 babel的编译器。(声明:现在我们谈论的是async关键字,而不是async包)

简而言之,使用async关键字,我们可以完成co和generators组合在一起做的事情——hacking编程方式除外。

图片 2

async函数的底层使用Promises——这就是为什么async函数将返回一个Promise。

如果我们想完成前面的例子中相同的事情,我们可能不得不重写代码片段如下:

JavaScript

async function save(Something) { try { await Something.save() } catch (ex) { //error handling } console.log('success'); }

1
2
3
4
5
6
7
8
async function save(Something) {  
  try {
    await Something.save()
  } catch (ex) {
    //error handling
  }
  console.log('success');
}

正如你所看到的,使用一个async函数,你必须把async关键字放在函数声明前。之后,你可以在你新创建的async函数中使用await关键字。

使用async函数并行运行事务和yield方法非常类似,除非现在Promise.all没有隐藏,但你必须调用它:

JavaScript

async function save(Something) { await Promise.all[Something.save(), Otherthing.save()] }

1
2
3
async function save(Something) {  
  await Promise.all[Something.save(), Otherthing.save()]
}

Koa 已经支持async功能,所以你今天就可以使用babel来试用他们。

JavaScript

import koa from koa; let app = koa(); app.experimental = true; app.use(async function (){ this.body = await Promise.resolve('Hello Reader!') }) app.listen(3000);

1
2
3
4
5
6
7
8
9
10
import koa from koa;  
let app = koa();
 
app.experimental = true;
 
app.use(async function (){  
  this.body = await Promise.resolve('Hello Reader!')
})
 
app.listen(3000);

Promise

当前的JavaScript异步标准可以追溯到2012年,并且直到ES6才变得可用,然而,Promise这个术语却并不是JavaScript 社区所发明的。这个术语来来自于Daniel P.friedman 在1976年的发表的一篇文章。

一个Promise代表的是一个异步操作的最终结果。

现在我们使用Promise来完成上面代码所完成的任务,Promise风格的代码如下:

JavaScript

Something.save() .then(function() { console.log('success'); }) .catch(function() { //error handling })

1
2
3
4
5
6
7
Something.save()  
    .then(function() {
        console.log('success');
    })
    .catch(function() {
        //error handling
    })

你会发现,Promise中也利用了回调函数。在thencatch方法中都传入了一个回调函数,分别在Promise被 满足和被拒绝时执行。Promise函数的另一个优点是它能够被链接起来完成一系列任务。例如,你可以这样写代码:

JavaScript

saveSomething() .then(updateOtherthing) .then(deleteStuff) .then(logResults);

1
2
3
4
saveSomething()  
    .then(updateOtherthing)
    .then(deleteStuff)  
    .then(logResults);

当你没有现成的Promise时,你可能需要借助一些Promise库,一个流行的选择是使用bluebird。 这些库可能会提供比原生方案更多的功能,并且不局限于Promise/A+标准所规定的特性。

但是你为什么不用糖方法(sugar methods)呢?建议你首先阅读Promise: The Extension Problem 这篇文章。更多关于Promise的信息,可以参考Promise/A+标准。

你可能会问: 如果大部分的库只暴露了回调的接口的话,那么我该如何使用Promise? 嗯,这个很简单,此时你唯一需要做的就是使用Promise来包裹含有回调的那个函数调用体。举例说明:

回调风格的代码可能是这样的:

JavaScript

function saveToTheDb(value) { db.values.insert(value, function (err, user) { if (err) throw err; // todo: insert user to db }); }

1
2
3
4
5
6
7
function saveToTheDb(value) {
    db.values.insert(value, function (err, user) {
        if (err) throw err;
 
        // todo: insert user to db
    });
}

现在我们来将其改成支持Promise风格调用的代码:

JavaScript

function saveToTheDb(value) { return new Promise(function(resolve, reject) { db.values.insert(value, function(err, user) { // remember error first ;) if (err) { return reject(err); // don't forget to return here } resolve(user); }) } }

1
2
3
4
5
6
7
8
9
10
function saveToTheDb(value) {  
    return new Promise(function(resolve, reject) {
        db.values.insert(value, function(err, user) { // remember error first ;)
            if (err) {
                return reject(err); // don't forget to return here
            }
            resolve(user);
        })
    }
}

已经有相当一部分的库或框架同时支持者两种方式了,即同时提供了回调风格和Promise风格的API接口。那么现在, 如果你也想对外提供一个库,最佳实践也是同时提供两种方式的接口。你可以轻松的使用如下方式来达到这个目的:

JavaScript

function foo(cb) { if (cb) { return cb(); } return new Promise(function (resolve, reject) { }); }

1
2
3
4
5
6
7
8
9
function foo(cb) {  
    if (cb) {
        return cb();
    }
 
    return new Promise(function (resolve, reject) {
 
    });
}

或者更简单些,你可以从只提供Promise风格的接口开始后,并使用诸如callbackify 这样的工具来达到向后兼容的目的。其实Callbackify所做的工作和上面的代码片段类似,但在实现上使用了一个更通用的方法, 我建议你可以去阅读Callbackify的源代码。

并发操作

Promise 还有另一个伟大的特性,它们可以同时进行多个异步操作,等他们全部完成之后再继续进行其它事件。ES2015 规范中提供了 Promise.all(),就是用来干这个事情的。

这里有一个示例:

function doAsyncOp() {   return Promise.all([     asynchronousOperation(),     asynchronousOperation()   ]).then(function(vals) {     vals.forEach(console.log);     return vals;   }); }

1
2
3
4
5
6
7
8
9
function doAsyncOp() {
  return Promise.all([
    asynchronousOperation(),
    asynchronousOperation()
  ]).then(function(vals) {
    vals.forEach(console.log);
    return vals;
  });
}

Promise.all() 也可以当作 async 函数使用:

async function doAsyncOp() {   var vals = await Promise.all([     asynchronousOperation(),     asynchronousOperation()   ]);   vals.forEach(console.log.bind(console));   return vals; }

1
2
3
4
5
6
7
8
async function doAsyncOp() {
  var vals = await Promise.all([
    asynchronousOperation(),
    asynchronousOperation()
  ]);
  vals.forEach(console.log.bind(console));
  return vals;
}

这里就算使用了 Promise.all,代码仍然很清楚。

异步链式调用

任何返回 Promise 的函数都可以通过 .then() 链式调用。前一个 resolve 的结果会传递给后一个:

asyncDBconnect('') .then(asyncGetSession) // 传递 asyncDBconnect 的结果 .then(asyncGetUser) // 传递 asyncGetSession 的结果 .then(asyncLogAccess) // 传递 asyncGetUser 的结果 .then(result => { // 同步函数 console.log('complete'); // (传递 asyncLogAccess 的结果) return result; // (结果传给下一个 .then()) }) .catch(err => { // 任何一个 reject 触发 console.log('error', err); });

1
2
3
4
5
6
7
8
9
10
11
asyncDBconnect('http://localhost:1234')
  .then(asyncGetSession)      // 传递 asyncDBconnect 的结果
  .then(asyncGetUser)         // 传递 asyncGetSession 的结果
  .then(asyncLogAccess)       // 传递 asyncGetUser 的结果
  .then(result => {           // 同步函数
    console.log('complete');  //   (传递 asyncLogAccess 的结果)
    return result;            //   (结果传给下一个 .then())
  })
  .catch(err => {             // 任何一个 reject 触发
    console.log('error', err);
  });

同步函数也可以执行 .then(),返回的值传递给下一个 .then()(如果有)。

当任何一个前面的 reject 触发时,.catch() 函数会被调用。触发 reject 的函数后面的 .then() 也不再执行。贯穿整个链条可以存在多个 .catch() 方法,从而捕获不同的错误。

ES2018 引入了 .finally() 方法,它不管返回结果如何,都会执行最终逻辑 – 例如,清理操作,关闭数据库连接等等。当前仅有 Chrome 和 Firefox 支持,但是 TC39 技术委员会已经发布了 .finally() 补丁。

function doSomething() { doSomething1() .then(doSomething2) .then(doSomething3) .catch(err => { console.log(err); }) .finally(() => { // 清理操作放这儿! }); }

1
2
3
4
5
6
7
8
9
10
11
function doSomething() {
  doSomething1()
  .then(doSomething2)
  .then(doSomething3)
  .catch(err => {
    console.log(err);
  })
  .finally(() => {
    // 清理操作放这儿!
  });
}

延伸阅读

目前我们在大部分新项目的生产环境中使用Hapi with generators ,同时也使用 Koa。

1 赞 收藏 评论

生成器Generators/ yield

JavaScript生成器是个相对较新的概念, 它是ES6(也被称为ES2015)的新特性。想象下面这样的一个场景:

当你在执行一个函数的时候,你可以在某个点暂停函数的执行,并且做一些其他工作,然后再返回这个函数继续执行, 甚至是携带一些新的值,然后继续执行。

上面描述的场景正是JavaScript生成器函数所致力于解决的问题。当我们调用一个生成器函数的时候,它并不会立即执行, 而是需要我们手动的去执行迭代操作(next方法)。也就是说,你调用生成器函数,它会返回给你一个迭代器。迭代器 会遍历每个中断点。

JavaScript

function* foo () { var index = 0; while (index < 2) { yield index++; //暂停函数执行,并执行yield后的操作 } } var bar = foo(); // 返回的其实是一个迭代器 console.log(bar.next()); // { value: 0, done: false } console.log(bar.next()); // { value: 1, done: false } console.log(bar.next()); // { value: undefined, done: true }

1
2
3
4
5
6
7
8
9
10
11
function* foo () {  
    var index = 0;
    while (index < 2) {
        yield index++; //暂停函数执行,并执行yield后的操作
    }
}
var bar =  foo(); // 返回的其实是一个迭代器
 
console.log(bar.next());    // { value: 0, done: false }  
console.log(bar.next());    // { value: 1, done: false }  
console.log(bar.next());    // { value: undefined, done: true }

更进一步的,如果你想更轻松的使用生成器函数来编写异步JavaScript代码,我们可以使用co 这个库,co是著名的tj大神写的。

Co是一个为Node.js和浏览器打造的基于生成器的流程控制工具,借助于Promise,你可以使用更加优雅的方式编写非阻塞代码。

使用co,前面的示例代码,我们可以使用下面的代码来改写:

JavaScript

co(function* (){ yield Something.save(); }).then(function() { // success }) .catch(function(err) { //error handling });

1
2
3
4
5
6
7
8
co(function* (){  
    yield Something.save();
}).then(function() {
    // success
})
  .catch(function(err) {
    //error handling
});

你可能会问:如何实现并行操作呢?答案可能比你想象的简单,如下(其实它就是Promise.all而已):

JavaScript

yield [Something.save(), Otherthing.save()];

1
yield [Something.save(), Otherthing.save()];

处理拒绝

Promises 可以被接受(resovled)也可以被拒绝(rejected)。被拒绝的 Promise 可以通过一个函数来处理,这个处理函数要传递给 then,作为其第二个参数,或者传递给 catch 方法。现在我们没有使用 Promise API 中的方法,应该怎么处理拒绝?可以通过 try 和 catch 来处理。使用 async 函数的时候,拒绝被当作错误来传递,这样它们就可以通过 JavaScript 本身支持的错误处理代码来处理。

function doAsyncOp() {   return asynchronousOperation()     .then(function(val) {       return asynchronousOperation(val);     })     .then(function(val) {       return asynchronousOperation(val);     })     .catch(function(err) {       console.error(err);     }); }

1
2
3
4
5
6
7
8
9
10
11
12
function doAsyncOp() {
  return asynchronousOperation()
    .then(function(val) {
      return asynchronousOperation(val);
    })
    .then(function(val) {
      return asynchronousOperation(val);
    })
    .catch(function(err) {
      console.error(err);
    });
}

这与我们链式处理的示例非常相似,只是把它的最后一环改成了调用 catch。如果用 async 函数来写,会像下面这样。

async function doAsyncOp () {   try {     var val = await asynchronousOperation();     val = await asynchronousOperation(val);     return await asynchronousOperation(val);   } catch (err) {     console.err(err);   } };

1
2
3
4
5
6
7
8
9
async function doAsyncOp () {
  try {
    var val = await asynchronousOperation();
    val = await asynchronousOperation(val);
    return await asynchronousOperation(val);
  } catch (err) {
    console.err(err);
  }
};

它不像其它往 async 函数的转换那样简洁,但是确实跟写同步代码一样。如果你在这里不捕捉错误,它会延着调用链一直向上抛出,直到在某处被捕捉处理。如果它一直未被捕捉,它最终会中止程序并抛出一个运行时错误。Promise 以同样的方式运作,只是拒绝不当作错误来处理;它们可能只是一个说明错误情况的字符串。如果你不捕捉被创建为错误的拒绝,你会看到一个运行时错误,不过如果你只是使用一个字符串,会失败却不会有输出。

使用 Promise.all() 处理多个异步操作

Promise .then() 方法用于相继执行的异步函数。如果不关心顺序 – 比如,初始化不相关的组件 – 所有异步函数同时启动,直到最慢的函数执行 resolve,整个流程结束。

Promise.all() 适用于这种场景,它接收一个函数数组并且返回另一个 Promise。举例:

Promise.all([ async1, async2, async3 ]) .then(values => { // 返回值的数组 console.log(values); // (与函数数组顺序一致) return values; }) .catch(err => { // 任一 reject 被触发 console.log('error', err); });

1
2
3
4
5
6
7
8
Promise.all([ async1, async2, async3 ])
  .then(values => {           // 返回值的数组
    console.log(values);      // (与函数数组顺序一致)
    return values;
  })
  .catch(err => {             // 任一 reject 被触发
    console.log('error', err);
  });

任意一个异步函数 rejectPromise.all() 会立即结束。

关于作者:cucr

图片 3

新浪微博:@hop_ping 个人主页 · 我的文章 · 17

图片 4

Async/ await

在ES7(还未正式标准化)中引入了Async函数的概念,目前如果你想要使用的话,只能借助于babel 这样的语法转换器将其转为ES5代码。(提醒一点:我们现在讨论的是async关键字,而不是NPM中的async包)。

简而言之,使用async关键字,你可以轻松的达成之前使用生成器和co函数所做到的工作。当然,除了hack之外。

也许你会问,是否在ES7中有了async关键字,yield就变得不是那么重要了?

实际上,使用yield实现异步也不过是一种hack罢了,yield意味着懒次序(lazy sequences)和迭代器。 而await能够完美的分离这两点,首先让yield用于其最初的目的,其次使用await来执行异步操作。

在这背后,async函数实际使用的是Promise,也就是为什么async函数会返回一个Promise的原因。

因此,我们使用async函数来完成类似于前面代码所完成的工作,可以使用下面这样的方式来重新编写代码:

JavaScript

async function save(Something) { try { await Something.save(); // 等待await后面的代码执行完,类似于yield } catch (ex) { //error handling } console.log('success'); }

1
2
3
4
5
6
7
8
async function save(Something) {  
    try {
        await Something.save(); // 等待await后面的代码执行完,类似于yield
    } catch (ex) {
        //error handling
    }
    console.log('success');
}

正如你看到的那样,使用async函数,你需要在函数声明的最前面加上async关键字。这之后,你可以在 函数内部使用await关键字了,作用和之前的yield作用是类似的。

使用async函数完成并行任务与yiled的方式非常的相似,唯一不同的是,此时Promise.all不再是 隐式的,你需要显示的调用它:

JavaScript

async function save(Something) { await Promise.all[Something.save(), Otherthing.save()] }

1
2
3
async function save(Something) {  
    await Promise.all[Something.save(), Otherthing.save()]
}

Koa也支持async函数,如果你也在使用koa,那么你现在就可以借助babel使用这一特性了。

JavaScript

import koa from koa; let app = koa(); app.experimental = true; app.use(async function (){ this.body = await Promise.resolve('Hello Reader!') }) app.listen(3000);

1
2
3
4
5
6
7
8
9
10
import koa from koa;  
let app = koa();
 
app.experimental = true;
 
app.use(async function (){  
    this.body = await Promise.resolve('Hello Reader!')
})
 
app.listen(3000);

中断 Promise

拒绝原生的 Promise,只需要使用 Promise 构建函数中的 reject 就好,当然也可以直接抛出错误——在 Promise 的构造函数中,在 then 或 catch 的回调中抛出都可以。如果是在其它地方抛出错误,Promise 就管不了了。

这里有一些拒绝 Promise 的示例:

function doAsyncOp() {   return new Promise(function(resolve, reject) {     if (somethingIsBad) {       reject("something is bad");     }     resolve("nothing is bad");   }); } /*-- or --*/ function doAsyncOp() {   return new Promise(function(resolve, reject) {     if (somethingIsBad) {       reject(new Error("something is bad"));     }     resolve("nothing is bad");   }); } /*-- or --*/ function doAsyncOp() {   return new Promise(function(resolve, reject) {     if (somethingIsBad) {       throw new Error("something is bad");     }     resolve("nothing is bad");   }); }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
function doAsyncOp() {
  return new Promise(function(resolve, reject) {
    if (somethingIsBad) {
      reject("something is bad");
    }
    resolve("nothing is bad");
  });
}
 
/*-- or --*/
 
function doAsyncOp() {
  return new Promise(function(resolve, reject) {
    if (somethingIsBad) {
      reject(new Error("something is bad"));
    }
    resolve("nothing is bad");
  });
}
 
/*-- or --*/
 
function doAsyncOp() {
  return new Promise(function(resolve, reject) {
    if (somethingIsBad) {
      throw new Error("something is bad");
    }
    resolve("nothing is bad");
  });
}

一般来说,最好使用 new Error,因为它会包含错误相关的其它信息,比如抛出位置的行号,以及可能会有用的调用栈。

这里有一些抛出 Promise 不能捕捉的错误的示例:

function doAsyncOp() {   // the next line will kill execution   throw new Error("something is bad");   return new Promise(function(resolve, reject) {     if (somethingIsBad) {       throw new Error("something is bad");     }     resolve("nothing is bad");   }); } // assume `doAsyncOp` does not have the killing error function x() {   var val = doAsyncOp().then(function() {     // this one will work just fine     throw new Error("I just think an error should be here");   });   // this one will kill execution   throw new Error("The more errors, the merrier");   return val; }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
function doAsyncOp() {
  // the next line will kill execution
  throw new Error("something is bad");
  return new Promise(function(resolve, reject) {
    if (somethingIsBad) {
      throw new Error("something is bad");
    }
    resolve("nothing is bad");
  });
}
 
// assume `doAsyncOp` does not have the killing error
function x() {
  var val = doAsyncOp().then(function() {
    // this one will work just fine
    throw new Error("I just think an error should be here");
  });
  // this one will kill execution
  throw new Error("The more errors, the merrier");
  return val;
}

在 async 函数的 Promise 中抛出错误就不会产生有关范围的问题——你可以在 async 函数中随时随地抛出错误,它总会被 Promise 抓住:

async function doAsyncOp() {   // the next line is fine   throw new Error("something is bad");   if (somethingIsBad) {     // this one is good too     throw new Error("something is bad");   }   return "nothing is bad"; }  // assume `doAsyncOp` does not have the killing error async function x() {   var val = await doAsyncOp();   // this one will work just fine   throw new Error("I just think an error should be here");   return val; }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
async function doAsyncOp() {
  // the next line is fine
  throw new Error("something is bad");
  if (somethingIsBad) {
    // this one is good too
    throw new Error("something is bad");
  }
  return "nothing is bad";
 
// assume `doAsyncOp` does not have the killing error
async function x() {
  var val = await doAsyncOp();
  // this one will work just fine
  throw new Error("I just think an error should be here");
  return val;
}

当然,我们永远不会运行到 doAsyncOp 中的第二个错误,也不会运行到 return 语句,因为在那之前抛出的错误已经中止了函数运行。

使用 Promise.race() 处理多个异步操作

Promise.race()Promise.all() 极其相似,不同之处在于,当首个 Promise resolve 或者 reject 时,它将会 resolve 或者 reject。仅有最快的异步函数会被执行:

Promise.race([ async1, async2, async3 ]) .then(value => { // 单一值 console.log(value); return value; }) .catch(err => { // 任一 reject 被触发 console.log('error', err); });

1
2
3
4
5
6
7
8
Promise.race([ async1, async2, async3 ])
  .then(value => {            // 单一值
    console.log(value);
    return value;
  })
  .catch(err => {             // 任一 reject 被触发
    console.log('error', err);
  });

拓展阅读

  1. Hapi with generators
  2. Koa

    1 赞 4 收藏 评论

问题

如果你刚开始使用 async 函数,需要小心嵌套函数的问题。比如,如果你的 async 函数中有另一个函数(通常是回调),你可能认为可以在其中使用 await ,但实际不能。你只能直接在 async 函数中使用 await 。

比如,这段代码无法运行:

async function getAllFiles(fileNames) {   return Promise.all(     fileNames.map(function(fileName) {       var file = await getFileAsync(fileName);       return parse(file);     })   ); }

1
2
3
4
5
6
7
8
async function getAllFiles(fileNames) {
  return Promise.all(
    fileNames.map(function(fileName) {
      var file = await getFileAsync(fileName);
      return parse(file);
    })
  );
}

第 4 行的 await 无效,因为它是在一个普通函数中使用的。不过可以通过为回调函数添加 async 关键字来解决这个问题。

async function getAllFiles(fileNames) {   return Promise.all(     fileNames.map(async function(fileName) {       var file = await getFileAsync(fileName);       return parse(file);     })   ); }

1
2
3
4
5
6
7
8
async function getAllFiles(fileNames) {
  return Promise.all(
    fileNames.map(async function(fileName) {
      var file = await getFileAsync(fileName);
      return parse(file);
    })
  );
}

你看到它的时候会觉得理所当然,即便如此,仍然需要小心这种情况。

也许你还想知道等价的使用 Promise 的代码:

function getAllFiles(fileNames) {   return Promise.all(     fileNames.map(function(fileName) {       return getFileAsync(fileName).then(function(file) {         return parse(file);       });     })   ); }

1
2
3
4
5
6
7
8
9
function getAllFiles(fileNames) {
  return Promise.all(
    fileNames.map(function(fileName) {
      return getFileAsync(fileName).then(function(file) {
        return parse(file);
      });
    })
  );
}

接下来的问题是关于把 async 函数看作同步函数。需要记住的是,async 函数内部的的代码是同步运行的,但是它会立即返回一个 Promise,并继续运行外面的代码,比如:

var a = doAsyncOp(); // one of the working ones from earlier console.log(a); a.then(function() {   console.log("`a` finished"); }); console.log("hello"); /* -- will output -- */ Promise Object hello `a` finished

1
2
3
4
5
6
7
8
9
10
11
var a = doAsyncOp(); // one of the working ones from earlier
console.log(a);
a.then(function() {
  console.log("`a` finished");
});
console.log("hello");
 
/* -- will output -- */
Promise Object
hello
`a` finished

你会看到 async 函数实际使用了内置的 Promise。这让我们思考 async 函数中的同步行为,其它人可以通过普通的 Promise API 调用我们的 async 函数,也可以使用它们自己的 async 函数来调用。

前途光明吗?

Promise 减少了回调地狱,但是引入了其他的问题。

教程常常不提,整个 Promise 链条是异步的,一系列的 Promise 函数都得返回自己的 Promise 或者在最终的 .then().catch() 或者 .finally() 方法里面执行回调。

我也承认:Promise 困扰了我很久。语法看起来比回调要复杂,好多地方会出错,调试也成问题。可是,学习基础还是很重要滴。

延伸阅读:

  • MDN Promise documentation
  • JavaScript Promises: an Introduction
  • JavaScript Promises … In Wicked Detail
  • Promises for asynchronous programming

如今,更好的异步代码!

即使你本身不能使用异步代码,你也可以进行编写或使用工具将其编译为 ES5。 异步函数能让代码更易于阅读,更易于维护。 只要我们有 source maps,我们可以随时使用更干净的 ES2017 代码。

有许多可以将异步功能(和其他 ES2015+功能)编译成 ES5 代码的工具。 如果您使用的是 Babel,这只是安装 ES2017 preset 的例子。

1 赞 1 收藏 评论

图片 5

Async/Await

Promise 看起来有点复杂,所以 ES2017 引进了 asyncawait。虽然只是语法糖,却使 Promise 更加方便,并且可以避免 .then() 链式调用的问题。看下面使用 Promise 的例子:

function connect() { return new Promise((resolve, reject) => { asyncDBconnect('') .then(asyncGetSession) .then(asyncGetUser) .then(asyncLogAccess) .then(result => resolve(result)) .catch(err => reject(err)) }); } // 运行 connect 方法 (自执行方法) (() => { connect(); .then(result => console.log(result)) .catch(err => console.log(err)) })();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
function connect() {
 
  return new Promise((resolve, reject) => {
 
    asyncDBconnect('http://localhost:1234')
      .then(asyncGetSession)
      .then(asyncGetUser)
      .then(asyncLogAccess)
      .then(result => resolve(result))
      .catch(err => reject(err))
 
  });
}
 
// 运行 connect 方法 (自执行方法)
(() => {
  connect();
    .then(result => console.log(result))
    .catch(err => console.log(err))
})();

使用 async / await 重写上面的代码:

  1. 外部方法用 async 声明
  2. 基于 Promise 的异步方法用 await 声明,可以确保下一个命令执行前,它已执行完成

async function connect() { try { const connection = await asyncDBconnect(''), session = await asyncGetSession(connection), user = await asyncGetUser(session), log = await asyncLogAccess(user); return log; } catch (e) { console.log('error', err); return null; } } // 运行 connect 方法 (自执行异步函数) (async () => { await connect(); })();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
async function connect() {
 
  try {
    const
      connection = await asyncDBconnect('http://localhost:1234'),
      session = await asyncGetSession(connection),
      user = await asyncGetUser(session),
      log = await asyncLogAccess(user);
 
    return log;
  }
  catch (e) {
    console.log('error', err);
    return null;
  }
 
}
 
// 运行 connect 方法 (自执行异步函数)
(async () => { await connect(); })();

await 使每个异步调用看起来像是同步的,同时不耽误 JavaScript 的单线程处理。此外,async 函数总是返回一个 Promise 对象,因此它可以被其他 async 函数调用。

async / await 可能不会让代码变少,但是有很多优点:

  1. 语法更清晰。括号越来越少,出错的可能性也越来越小。
  2. 调试更容易。可以在任何 await 声明处设置断点。
  3. 错误处理尚佳。try / catch 可以与同步代码使用相同的处理方式。
  4. 支持良好。所有浏览器(除了 IE 和 Opera Mini )和 Node7.6+ 均已实现。

如是说,没有完美的…

Promises, Promises

async / await 仍然依赖 Promise 对象,最终依赖回调。你需要理解 Promise 的工作原理,它也并不等同于 Promise.all()Promise.race()。比较容易忽视的是 Promise.all(),这个命令比使用一系列无关的 await 命令更高效。

同步循环中的异步等待

某些情况下,你想要在同步循环中调用异步函数。例如:

async function process(array) { for (let i of array) { await doSomething(i); } }

1
2
3
4
5
async function process(array) {
  for (let i of array) {
    await doSomething(i);
  }
}

不起作用,下面的代码也一样:

async function process(array) { array.forEach(async i => { await doSomething(i); }); }

1
2
3
4
5
async function process(array) {
  array.forEach(async i => {
    await doSomething(i);
  });
}

循环本身保持同步,并且总是在内部异步操作之前完成。

ES2018 引入异步迭代器,除了 next() 方法返回一个 Promise 对象之外,与常规迭代器类似。因此,await 关键字可以与 for ... of 循环一起使用,以串行方式运行异步操作。例如:

async function process(array) { for await (let i of array) { doSomething(i); } }

1
2
3
4
5
async function process(array) {
  for await (let i of array) {
    doSomething(i);
  }
}

然而,在异步迭代器实现之前,最好的方案是将数组每项 mapasync 函数,并用 Promise.all() 执行它们。例如:

const todo = ['a', 'b', 'c'], alltodo = todo.map(async (v, i) => { console.log('iteration', i); await processSomething(v); }); await Promise.all(alltodo);

1
2
3
4
5
6
7
8
const
  todo = ['a', 'b', 'c'],
  alltodo = todo.map(async (v, i) => {
    console.log('iteration', i);
    await processSomething(v);
});
 
await Promise.all(alltodo);

这样有利于执行并行任务,但是无法将一次迭代结果传递给另一次迭代,并且映射大数组可能会消耗计算性能。

丑陋的 try/catch

如果执行失败的 await 没有包裹 try / catchasync 函数将静默退出。如果有一长串异步 await 命令,需要多个 try / catch 包裹。

替代方案是使用高阶函数来捕捉错误,不再需要 try / catch 了(感谢@wesbos的建议):

async function connect() { const connection = await asyncDBconnect(''), session = await asyncGetSession(connection), user = await asyncGetUser(session), log = await asyncLogAccess(user); return true; } // 使用高阶函数捕获错误 function catchErrors(fn) { return function (...args) { return fn(...args).catch(err => { console.log('ERROR', err); }); } } (async () => { await catchErrors(connect)(); })();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
async function connect() {
 
  const
    connection = await asyncDBconnect('http://localhost:1234'),
    session = await asyncGetSession(connection),
    user = await asyncGetUser(session),
    log = await asyncLogAccess(user);
 
  return true;
}
 
// 使用高阶函数捕获错误
function catchErrors(fn) {
  return function (...args) {
    return fn(...args).catch(err => {
      console.log('ERROR', err);
    });
  }
}
 
(async () => {
  await catchErrors(connect)();
})();

当应用必须返回区别于其它的错误时,这种作法就不太实用了。

尽管有一些缺陷,async/await 还是 JavaScript 非常有用的补充。更多资源:

  • MDN async 和 await
  • 异步函数 – 提高 Promise 的易用性
  • TC39 异步函数规范
  • 用异步函数简化异步编码

JavaScript 之旅

异步编程是 JavaScript 无法避免的挑战。回调在大多数应用中是必不可少的,但是容易陷入深度嵌套的函数中。

Promise 抽象了回调,但是有许多句法陷阱。转换已有函数可能是一件苦差事,·then() 链式调用看起来很凌乱。

很幸运,async/await 表达清晰。代码看起来是同步的,但是又不独占单个处理线程。它将改变你书写 JavaScript 的方式,甚至让你更赏识 Promise – 如果没接触过的话。

1 赞 收藏 评论

图片 6

本文由金沙棋牌发布于金沙棋牌官方平台,转载请注明出处:异步JavaScript的发展历程,从回调函数到

关键词:

上一篇:没有了

下一篇:CSS3四个自适应关键字