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

01.JSONP

JSONP是可以跨域的异步非阻塞任务,其原理是:
在当前DOM树里新添加一个<script>标签,通过其src属性发起一个http/https请求向服务器端请求API,让其异步非阻塞地返回一段远程JS代码,然后在客户端执行该远程代码。
比如:
1
//用来执行远程JS代码的函数,名字需要与服务器端约定一致
2
function jsonpProcess (data) {
3
console.log(data)
4
}
5
6
function jsonp_Script () {
7
var _script = document.createElement("script");
8
_script.type = "text/javascript";
9
//服务器端API地址,注意callback传的值,该值要和第2行的函数名字一致
10
_script.src = "http://www.xxx.com/api.php?callback=jsonpProcess";
11
document.head.appendChild(_script)
12
}
13
14
jsonp_Script();
Copied!
JSONP会约定请求上面的服务器端API的url地址http://www.xxx.com/api.php?callback=jsonpProcess 会返回JS代码:
1
//该函数名由url中的callback参数决定,且与客户端代码中的执行远程JS代码的函数名一致
2
jsonpProcess({
3
//json data
4
test:"coffe1891"
5
});
Copied!
也即返回的代码,是以一个名为jsonpProcess的函数包着一段json数据,这个名字jsonpProcess可以是约定是任意名字,只要通过url传给服务器端callback参数的名字和客户端用来执行远程js代码的函数名一致就行。

02.SetTimeOut/SetInterVal

1
//异步代码
2
setTimeout(function () { //属于宏任务
3
console.log('1');
4
},0);
5
6
//同步代码
7
function main(){
8
console.log('2');
9
}
10
console.log('3');
11
console.log('4');
12
main();
13
14
//>> 3
15
//>> 4
16
//>> 2
17
//>> 1
Copied!

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的功能。
完整的例子如下:
1
var xhr = new XMLHttpRequest();
2
xhr.open('GET', url);
3
xhr.responseType = 'json';
4
5
xhr.onload = function() {
6
console.log(xhr.response);
7
};
8
9
xhr.onerror = function() {
10
console.log("Oops, error");
11
};
12
13
xhr.send();
Copied!

04.Fetch+Promise

ES6的Promise本身并不是异步的,它只是实现了对异步回调的统一封装。所以实际上Promise写在本篇并不恰当,但是作为与异步回调密切相关的“范式”,也可以捎带提一下。
1
new Promise(resolve => { //属于微任务
2
//请注意:下面这行代码是立即、同步执行的代码!!Promise本身并不是异步的!!
3
console.log('1');
4
//在本例中,我们使用setTimeout(...)来模拟异步代码,实际编码时可能是XHR请求或是HTML5的一些API方法.
5
setTimeout(function () {
6
resolve("2"); //代码正常执行!
7
}, 250);
8
}).then(data => { console.log(data) });//then(..)异步回调的统一封装
9
10
//>> 1
11
//>> 2
Copied!
Fetch会返回一个Promise对象。Fetch的基本用法(ES6 语法)如下:
1
fetch(url,option).then((response) => {
2
// 做点什么事
3
});
Copied!

05.Generator & async/await

Generator 函数是协程在 ES6 的实现,最大特点就是可以交出函数的执行权(即暂停执行)。整个 Generator 函数就是一个封装的异步任务,或者说是异步任务的容器。异步操作需要暂停的地方,都用yield语句注明。下面用 Generator 函数依次读取两个文件:
1
var fs = require('fs');
2
var readFile = function (fileName) {
3
return new Promise(function (resolve, reject) {
4
fs.readFile(fileName, function (error, data) {
5
if (error) reject(error);
6
resolve(data);
7
});
8
});
9
};
10
var gen = function* () {
11
var f1 = yield readFile('/etc/fstab');
12
var f2 = yield readFile('/etc/shells');
13
console.log(f1.toString());
14
console.log(f2.toString());
15
};
Copied!
ES2017 标准引入了 async 函数,使得异步操作变得更加方便。上面的代码用async函数实现如下:
1
var asyncReadFile = async function () {
2
var f1 = await readFile('/etc/fstab');
3
var f2 = await readFile('/etc/shells');
4
console.log(f1.toString());
5
console.log(f2.toString());
6
};
Copied!
async 函数其实就是 Generator 函数的语法糖。

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

1) 内置执行器 Generator 函数的执行必须靠执行器,所以才有了co模块,而async函数自带执行器。也就是说,async函数的执行,与普通函数一模一样,只要一行。
1
var result = asyncReadFile();
Copied!
上面的代码调用了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后面的语句。
1
function timeout(ms) {
2
return new Promise((resolve) => {
3
setTimeout(resolve, ms);//模拟耗时操作
4
});
5
}
6
async function asyncPrint(value, ms) {
7
await timeout(ms);
8
console.log(value);
9
}
10
asyncPrint('hello coffe1891', 1000);
Copied!
上面代码指定1000毫秒以后,输出hello coffe1891。由于async函数返回的是 Promise 对象,而该Promise对象可以作为await命令的参数。所以,上面的例子也可以写成下面嵌套的形式:
1
/*嵌套的async*/
2
async function timeout(ms) {
3
await new Promise((resolve) => {
4
setTimeout(resolve, ms);//模拟耗时操作
5
});
6
}
7
async function asyncPrint(value, ms) {
8
await timeout(ms);
9
console.log(value);
10
}
11
asyncPrint('hello coffe1891', 1000);
Copied!
  • async函数内部return语句返回的值,会成为then方法回调函数的参数。
1
async function f() {
2
return 'hello coffe1891';
3
}
4
f().then(v => console.log(v)) //>> hello coffe1891
Copied!
  • await 命令后面的 Promise对象结果可能是 rejected,因此需要对此进行捕获,以免错误丢失;所以最好把await命令放在try...catch代码块中。
1
async function myFunction() {
2
try {
3
await somethingThatReturnsAPromise();
4
} catch (err) {
5
console.log(err);
6
}
7
}
8
// 另一种写法
9
async function myFunction() {
10
await doSomethingAndGetAPromise().catch(function (err) {
11
console.log(err);
12
});
13
}
Copied!
  • 多个await命令后面的异步操作如果不存在继发关系,最好让它们同时触发(并发): Promise.all;
1
let foo = await getFoo();
2
let bar = await getBar();
3
4
// 写法一
5
let [foo, bar] = await Promise.all([getFoo(), getBar()]);
6
7
// 写法二
8
let fooPromise = getFoo();
9
let barPromise = getBar();
10
let foo = await fooPromise;
11
let bar = await barPromise;
Copied!
  • await 只能写在 async 函数中,如果使用ESM加载器,则await可以写在模块的顶层区域(不用放在async函数内。

async 函数实现的原理:

1
function spawn(genF) {
2
return new Promise(function(resolve, reject) {
3
const gen = genF();
4
function step(nextF) {
5
let next;
6
try {
7
next = nextF();
8
} catch(e) {
9
return reject(e);
10
}
11
if(next.done) {
12
return resolve(next.value);
13
}
14
Promise.resolve(next.value).then(function(v) {
15
step(function() { return gen.next(v); });
16
}, function(e) {
17
step(function() { return gen.throw(e); });
18
});
19
}
20
step(function() { return gen.next(undefined); });
21
});
22
}
Copied!
Promise 对象、Generator 函数、async 函数三者异步处理方式比较:
  • Promise 的 API(thencatch等等)太多,使得实际逻辑展示不清晰;
  • Generator 函数的执行必须依赖执行器;
  • async 函数实现简洁,语句清晰。

参考文献

最近更新 1yr ago