Skip to content

Latest commit

 

History

History
290 lines (225 loc) · 9.51 KB

1.2.13.md

File metadata and controls

290 lines (225 loc) · 9.51 KB

壹.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 函数实现简洁,语句清晰。

参考文献

{% hint style="info" %} Ajax知识体系大梳理 {% endhint %}