壹.2.13 实现异步非阻塞的任务

在“壹.2.7 同步和异步,阻塞和非阻塞”和“壹.2.8 Event Loop”已经介绍了异步、 非阻塞有关的基础理论知识。实现异步+非阻塞的任务,是日常开发中被较多需要的。本篇详细介绍几种利用原生JavaScript实现异步非阻塞任务的办法。

01.JSONP

JSONP是可以跨域的异步非阻塞任务,其原理是:

在当前DOM树里新添加一个<script>标签,通过其src属性发起一个http/https请求向服务器端请求API,让其异步非阻塞地返回一段远程JS代码,然后在客户端执行该远程代码。

比如:

//用来执行远程JS代码的函数,名字需要与服务器端约定一致
function jsonpProcess (data) {
console.log(data)
}
function jsonp_Script () {
var _script = document.createElement("script");
_script.type = "text/javascript";
//服务器端API地址,注意callback传的值,该值要和第2行的函数名字一致
_script.src = "http://www.xxx.com/api.php?callback=jsonpProcess";
document.head.appendChild(_script)
}
jsonp_Script();

JSONP会约定请求上面的服务器端API的url地址http://www.xxx.com/api.php?callback=jsonpProcess 会返回JS代码:

//该函数名由url中的callback参数决定,且与客户端代码中的执行远程JS代码的函数名一致
jsonpProcess({
//json data
test:"coffe1891"
});

也即返回的代码,是以一个名为jsonpProcess的函数包着一段json数据,这个名字jsonpProcess可以是约定是任意名字,只要通过url传给服务器端callback参数的名字和客户端用来执行远程js代码的函数名一致就行。

02.SetTimeOut/SetInterVal

//异步代码
setTimeout(function () { //属于宏任务
console.log('1');
},0);
//同步代码
function main(){
console.log('2');
}
console.log('3');
console.log('4');
main();
//>> 3
//>> 4
//>> 2
//>> 1

03.Ajax

Ajax 全称 Asynchronous JavaScript and XML, 即异步JS与XML。 它最早在IE5中被使用, 然后由Mozilla, Apple,Google推广开来. 典型的代表应用有 Outlook Web Access, 以及 GMail. 现代网页中几乎无ajax不欢。 前后端分离也正是建立在ajax异步通信的基础之上。

现代浏览器中, 虽然几乎全部支持ajax, 但它们的技术方案却分为两种:

  • 标准浏览器通过 XMLHttpRequest 对象实现了ajax的功能。只需要通过一行语句便可创建一个用于发送ajax请求的对象。

  • IE浏览器通过 XMLHttpRequest 或者 ActiveXObject 对象同样实现了ajax的功能。

完整的例子如下:

var xhr = new XMLHttpRequest();
xhr.open('GET', url);
xhr.responseType = 'json';
xhr.onload = function() {
console.log(xhr.response);
};
xhr.onerror = function() {
console.log("Oops, error");
};
xhr.send();

04.Fetch+Promise

ES6的Promise本身并不是异步的,它只是实现了对异步回调的统一封装。所以实际上Promise写在本篇并不恰当,但是作为与异步回调密切相关的“范式”,也可以捎带提一下。

new Promise(resolve => { //属于微任务
//请注意:下面这行代码是立即、同步执行的代码!!Promise本身并不是异步的!!
console.log('1');
//在本例中,我们使用setTimeout(...)来模拟异步代码,实际编码时可能是XHR请求或是HTML5的一些API方法.
setTimeout(function () {
resolve("2"); //代码正常执行!
}, 250);
}).then(data => { console.log(data) });//then(..)异步回调的统一封装
//>> 1
//>> 2

Fetch会返回一个Promise对象。Fetch的基本用法(ES6 语法)如下:

fetch(url,option).then((response) => {
// 做点什么事
});

05.Generator & async/await

Generator 函数是协程在 ES6 的实现,最大特点就是可以交出函数的执行权(即暂停执行)。整个 Generator 函数就是一个封装的异步任务,或者说是异步任务的容器。异步操作需要暂停的地方,都用yield语句注明。下面用 Generator 函数依次读取两个文件:

var fs = require('fs');
var readFile = function (fileName) {
return new Promise(function (resolve, reject) {
fs.readFile(fileName, function (error, data) {
if (error) reject(error);
resolve(data);
});
});
};
var gen = function* () {
var f1 = yield readFile('/etc/fstab');
var f2 = yield readFile('/etc/shells');
console.log(f1.toString());
console.log(f2.toString());
};

ES2017 标准引入了 async 函数,使得异步操作变得更加方便。上面的代码用async函数实现如下:

var asyncReadFile = async function () {
var f1 = await readFile('/etc/fstab');
var f2 = await readFile('/etc/shells');
console.log(f1.toString());
console.log(f2.toString());
};

async 函数其实就是 Generator 函数的语法糖。

async函数对 Generator 函数的改进,体现在以下四点:

1) 内置执行器 Generator 函数的执行必须靠执行器,所以才有了co模块,而async函数自带执行器。也就是说,async函数的执行,与普通函数一模一样,只要一行。

var result = asyncReadFile();

上面的代码调用了asyncReadFile函数,然后它就会自动执行,输出最后结果。这完全不像 Generator 函数,需要调用next方法,或者用co模块,才能真正执行,得到最后结果。

2) 更好的语义 async和await,比起星号和yield,语义更清楚了。async表示函数里有异步操作,await表示紧跟在后面的表达式需要等待结果。

3) 更广的适用性 co模块约定,yield命令后面只能是 Thunk 函数或 Promise 对象,而async函数的await命令后面,可以是Promise 对象和原始类型的值(数值、字符串和布尔值,但这时等同于同步操作)。

4) 返回值是 Promise async函数的返回值是 Promise 对象,这比 Generator 函数的返回值是 Iterator 对象方便多了。你可以用then方法指定下一步的操作。

进一步说,async函数完全可以看作多个异步操作包装成的一个 Promise 对象,而await命令就是内部then命令的语法糖。

async 注意点:

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

function timeout(ms) {
return new Promise((resolve) => {
setTimeout(resolve, ms);//模拟耗时操作
});
}
async function asyncPrint(value, ms) {
await timeout(ms);
console.log(value);
}
asyncPrint('hello coffe1891', 1000);

上面代码指定1000毫秒以后,输出hello coffe1891。由于async函数返回的是 Promise 对象,而该Promise对象可以作为await命令的参数。所以,上面的例子也可以写成下面嵌套的形式:

/*嵌套的async*/
async function timeout(ms) {
await new Promise((resolve) => {
setTimeout(resolve, ms);//模拟耗时操作
});
}
async function asyncPrint(value, ms) {
await timeout(ms);
console.log(value);
}
asyncPrint('hello coffe1891', 1000);
  • async函数内部return语句返回的值,会成为then方法回调函数的参数。

async function f() {
return 'hello coffe1891';
}
f().then(v => console.log(v)) //>> hello coffe1891
  • await 命令后面的 Promise对象结果可能是 rejected,因此需要对此进行捕获,以免错误丢失;所以最好把await命令放在try...catch代码块中。

async function myFunction() {
try {
await somethingThatReturnsAPromise();
} catch (err) {
console.log(err);
}
}
// 另一种写法
async function myFunction() {
await doSomethingAndGetAPromise().catch(function (err) {
console.log(err);
});
}
  • 多个await命令后面的异步操作如果不存在继发关系,最好让它们同时触发(并发): Promise.all;

let foo = await getFoo();
let bar = await getBar();
// 写法一
let [foo, bar] = await Promise.all([getFoo(), getBar()]);
// 写法二
let fooPromise = getFoo();
let barPromise = getBar();
let foo = await fooPromise;
let bar = await barPromise;
  • await 只能写在 async 函数中,如果使用ESM加载器,则await可以写在模块的顶层区域(不用放在async函数内。

async 函数实现的原理:

function spawn(genF) {
return new Promise(function(resolve, reject) {
const gen = genF();
function step(nextF) {
let next;
try {
next = nextF();
} catch(e) {
return reject(e);
}
if(next.done) {
return resolve(next.value);
}
Promise.resolve(next.value).then(function(v) {
step(function() { return gen.next(v); });
}, function(e) {
step(function() { return gen.throw(e); });
});
}
step(function() { return gen.next(undefined); });
});
}

Promise 对象、Generator 函数、async 函数三者异步处理方式比较:

  • Promise 的 API(thencatch等等)太多,使得实际逻辑展示不清晰;

  • Generator 函数的执行必须依赖执行器;

  • async 函数实现简洁,语句清晰。

参考文献