来自 前端知识 2019-11-14 17:53 的文章
当前位置: 金沙澳门官网网址 > 前端知识 > 正文

澳门金莎娱乐手机版异步JavaScript的发展历程

关于作者:cucr

澳门金莎娱乐手机版 1

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

澳门金莎娱乐手机版 2

生成器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()];

延伸阅读

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

1 赞 收藏 评论

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);

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

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基本上做了和之前显示的代码片段相同的工作,但方法更简单。

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的源代码。

Async、await函数

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

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

澳门金莎娱乐手机版 3

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);

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

本文由金沙澳门官网网址发布于前端知识,转载请注明出处:澳门金莎娱乐手机版异步JavaScript的发展历程

关键词: