实现异步非阻塞的任务

在“同步和异步，阻塞和非阻塞”和“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（then、catch等等）太多，使得实际逻辑展示不清晰；
• Generator 函数的执行必须依赖执行器；
• async 函数实现简洁，语句清晰。

参考文献

Ajax知识体系大梳理